@jetbrains/ring-ui 4.1.1 → 4.1.2

package/dist/message-bundle-ng/message-bundle-ng.js

@@ -0,0 +1,111 @@
+import angular from 'angular';
+
+/**
+ * This service is used by directive to correctly show messages.
+ * You can decorate this service to provide your own localized messages.
+ */
+
+const angularModule = angular.module('Ring.message-bundle', []);
+/**
+ * Empty i18n function. If project supports localization, it should decorate i18n
+ * with translating function
+ */
+
+function emptyI18n() {
+  return str => str;
+}
+
+function RingMessageBundle(ringI18n) {
+  const i18n = ringI18n;
+  /* eslint-disable camelcase */
+
+  this.form_required = () => i18n('Value is required');
+
+  this.form_invalid = () => i18n('Value is invalid');
+
+  this.form_url = () => i18n('Should be a valid URL');
+
+  this.form_email = () => i18n('Should be a valid email');
+
+  this.form_number = () => i18n('Should be a number');
+
+  this.form_maxlength = () => i18n('Is too long');
+
+  this.form_minlength = () => i18n('Is too short');
+
+  this.form_pattern = () => i18n('Doesn\'t match the pattern');
+
+  this.form_equalvalue = () => i18n('Is not the same');
+
+  this.form_unique = () => i18n('Is not unique');
+
+  this.form_max = () => i18n('Is out of range');
+
+  this.form_min = () => i18n('Is out of range');
+
+  this.form_save = () => i18n('Save');
+
+  this.form_saved = () => i18n('Saved');
+
+  this.form_cancel = () => i18n('Cancel');
+
+  this.avatareditor_nosupport = () => i18n('Sorry, your browser doesn\'t support File API');
+
+  this.avatareditor_noselected = () => i18n('No image file was selected');
+
+  this.avatareditor_delete = () => i18n('Delete Image');
+
+  this.avatareditor_add = () => i18n('Add Image');
+
+  this.errorpage_seriouslywrong = () => i18n('Oh-oh... Something went seriously wrong.');
+
+  this.errorpage_offline = () => i18n('There\'s nothing we can do: The server seems to be offline.');
+
+  this.errorpage_disconnected = () => i18n('Disconnected');
+
+  this.errorpage_disconnectedmsg = () => i18n('No, no one\'s there.');
+
+  this.errorpage_401 = () => i18n('Authorization required');
+
+  this.errorpage_401msg = () => i18n('You have requested access to a page that requires authorization, but the request is missing valid authentication credentials. It can also mean that your account has been banned.');
+
+  this.errorpage_403 = () => i18n('Woah, you can\'t touch this!');
+
+  this.errorpage_403msg = () => i18n('Unfortunately, you are not allowed to access the page you\'ve requested. It seems you don\'t have sufficient permissions.');
+
+  this.errorpage_404 = () => i18n('Nope, can\'t find it!');
+
+  this.errorpage_404msg = () => i18n('Despite our best efforts, there\'s nothing here to show you with the URL you requested. Most likely the URL is invalid or you don\'t have permissions to access the page.');
+
+  this.errorpage_500 = () => i18n('Oh-oh... Something went seriously wrong');
+
+  this.errorpage_500msg = () => i18n('Despite our best efforts, the server is not working properly.');
+
+  this.select_options_not_found = () => i18n('No options found');
+
+  this.select_loading = () => i18n('Loading...');
+
+  this.select_label = () => i18n('Select an option');
+
+  this.previous_page = () => i18n('previous');
+
+  this.next_page = () => i18n('next page');
+
+  this.first_page = () => i18n('First page');
+
+  this.last_page = () => i18n('Last page');
+
+  this.items_per_page = () => i18n('per page');
+
+  this.confirmation_ok = () => i18n('Ok');
+
+  this.confirmation_cancel = () => i18n('Cancel');
+  /* eslint-enable camelcase */
+
+}
+
+angularModule.factory('ringI18n', emptyI18n);
+angularModule.service('RingMessageBundle', ['ringI18n', RingMessageBundle]);
+var MessageBundle = angularModule.name;
+
+export { MessageBundle as default };

package/dist/old-browsers-message/old-browsers-message.js

@@ -0,0 +1,100 @@
+import { isBrowserInWhiteList } from './white-list.js';
+import '../global/sniffer.js';
+import 'sniffr';
+
+/**
+ * @name Old Browsers Message
+ */
+
+/**
+  The list of versions which are definitely supported. "Browser is unsupported"
+  won't be displayed for those and higher versions even when a JS error occurs
+  on application start.
+ */
+
+let smileChanges = 0;
+const MAX_SMILE_CHANGES = 50;
+let previousWindowErrorHandler;
+
+function changeSmileClickListener(event) {
+  const eyes = ['O', 'o', '-', '>', '<'];
+  const target = event.target || event.srcElement;
+  smileChanges++;
+
+  function rand(min, max) {
+    return Math.round(Math.random() * (max - min)) + min;
+  }
+
+  function getRandomEye() {
+    return eyes[rand(0, eyes.length - 1)];
+  }
+
+  function getRandomSmile() {
+    if (smileChanges >= MAX_SMILE_CHANGES) {
+      return '\\\\ (x_x) //';
+    }
+
+    return `{{ (${getRandomEye()}_${getRandomEye()}) }}`;
+  }
+
+  target.innerHTML = getRandomSmile();
+}
+
+function attachSmileClickListener(smileNode) {
+  if (smileNode.addEventListener) {
+    smileNode.addEventListener('click', changeSmileClickListener);
+  } else if (smileNode.attachEvent) {
+    smileNode.attachEvent('onclick', changeSmileClickListener);
+  }
+}
+/**
+ * Listens to unhandled errors and displays passed node
+ */
+
+
+function startOldBrowsersDetector(onOldBrowserDetected) {
+  previousWindowErrorHandler = window.onerror;
+
+  window.onerror = function oldBrowsersMessageShower(errorMsg, url, lineNumber) {
+    if (onOldBrowserDetected) {
+      onOldBrowserDetected();
+    }
+
+    if (previousWindowErrorHandler) {
+      return previousWindowErrorHandler(errorMsg, url, lineNumber);
+    }
+
+    return false;
+  };
+}
+
+function stopOldBrowserDetector() {
+  window.onerror = previousWindowErrorHandler;
+} //Start javascript error detection
+
+
+startOldBrowsersDetector(() => {
+  const oldBrowsersMessageContainer = document.getElementById('ring-old-browsers-message');
+  const browserMessage = document.getElementById('ring-old-browsers-message__browser-message');
+  const errorMessage = document.getElementById('ring-old-browsers-message__error-message');
+  const smileNode = document.getElementById('ring-old-browsers-message__smile');
+
+  if (isBrowserInWhiteList()) {
+    browserMessage.style.display = 'none';
+    errorMessage.style.display = 'block';
+  } else {
+    browserMessage.style.display = 'block';
+    errorMessage.style.display = 'none';
+  }
+
+  if (oldBrowsersMessageContainer) {
+    oldBrowsersMessageContainer.hidden = false;
+    oldBrowsersMessageContainer.style.display = 'block';
+  }
+
+  if (smileNode) {
+    attachSmileClickListener(smileNode);
+  }
+});
+
+export { stopOldBrowserDetector as stop };

package/dist/old-browsers-message/old-browsers-message__stop.js

@@ -0,0 +1,4 @@
+export { stop as default } from './old-browsers-message.js';
+import './white-list.js';
+import '../global/sniffer.js';
+import 'sniffr';

package/dist/old-browsers-message/white-list.js

@@ -0,0 +1,33 @@
+import sniffr from '../global/sniffer.js';
+import 'sniffr';
+
+const MAJOR_VERSION_INDEX = 0;
+/**
+ * SUPPORTED_BROWSERS are defined by Babel plugin, see babel config
+ */
+
+/* global SUPPORTED_BROWSERS */
+
+if (!["and_chr 90", "and_uc 12.12", "chrome 89", "chrome 88", "edge 89", "firefox 86", "ios_saf 14.0-14.4", "safari 14", "samsung 13.0"]) {
+  // eslint-disable-next-line no-console
+  console.warn('Ring UI: no SUPPORTED_BROWSERS passed. Please check babel config.');
+}
+
+const SUPPORTED = ["and_chr 90", "and_uc 12.12", "chrome 89", "chrome 88", "edge 89", "firefox 86", "ios_saf 14.0-14.4", "safari 14", "samsung 13.0"] || [];
+const WHITE_LISTED_BROWSERS = ['chrome', 'firefox', 'safari', 'edge'];
+const WHITE_LIST = SUPPORTED.reduce((acc, item) => {
+  const [, browserName, version] = item.match(/(\S+)\s(\S+)/);
+
+  if (!WHITE_LISTED_BROWSERS.includes(browserName)) {
+    return acc;
+  }
+
+  return { ...acc,
+    [browserName]: parseInt(version, 10)
+  };
+}, {});
+function isBrowserInWhiteList() {
+  return sniffr.browser.version[MAJOR_VERSION_INDEX] >= WHITE_LIST[sniffr.browser.name];
+}
+
+export { WHITE_LIST, isBrowserInWhiteList };

package/dist/pager/pager.js

@@ -0,0 +1,361 @@
+import { _ as _defineProperty, a as _extends } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import chevronLeftIcon from '@jetbrains/icons/chevron-left';
+import chevronRightIcon from '@jetbrains/icons/chevron-right';
+import Button from '../button/button.js';
+import ButtonGroup from '../button-group/button-group.js';
+import ButtonToolbar from '../button-toolbar/button-toolbar.js';
+import Select from '../select/select.js';
+import memoize from '../global/memoize.js';
+import Link from '../link/link.js';
+import Icon from '../icon/icon.js';
+import 'focus-visible';
+import '@jetbrains/icons/chevron-10px';
+import '../global/theme.js';
+import '../link/clickableLink.js';
+import '../_helpers/button__classes.js';
+import '../icon/icon__constants.js';
+import 'util-deprecate';
+import '../_helpers/icon.js';
+import '../icon/icon__svg.js';
+import '../button-group/caption.js';
+import '../_helpers/button-group.js';
+import '../_helpers/button-toolbar.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 'react-dom';
+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 '../_helpers/list.js';
+import '../_helpers/link.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 modules_1a5f0d42 = {"unit":"8px","pager":"pager_rui_4d14","links":"links_rui_4d14","link":"link_rui_4d14","linkDisabled":"linkDisabled_rui_4d14"};
+
+class Pager extends PureComponent {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "handlePageSizeChange", item => {
+      this.props.onPageSizeChange(item.key);
+    });
+
+    _defineProperty(this, "handlePrevClick", () => {
+      const {
+        currentPage
+      } = this.props;
+
+      if (currentPage !== 1) {
+        const prevPage = currentPage - 1;
+        this.props.onPageChange(prevPage);
+      }
+    });
+
+    _defineProperty(this, "handleNextClick", () => {
+      const {
+        currentPage,
+        onLoadPage
+      } = this.props;
+      const nextPage = currentPage + 1;
+      const total = this.getTotal();
+
+      if (currentPage !== total) {
+        this.props.onPageChange(nextPage);
+      } else if (this.props.openTotal) {
+        onLoadPage(nextPage);
+      }
+    });
+
+    _defineProperty(this, "handlePageChange", memoize(i => event => {
+      this.props.onPageChange(i, event);
+    }));
+
+    _defineProperty(this, "handleLoadMore", memoize(i => () => {
+      this.props.onLoadPage(i);
+    }));
+  }
+
+  getSelectOptions() {
+    const {
+      pageSize,
+      pageSizes
+    } = this.props;
+    const data = pageSizes.map(size => ({
+      key: size,
+      label: `${size} ${this.props.translations.perPage}`
+    }));
+    const selected = data.find(it => it.key === pageSize);
+    return {
+      selected,
+      data
+    };
+  }
+
+  getTotal() {
+    const {
+      total,
+      pageSize
+    } = this.props;
+    return Math.ceil(total / pageSize);
+  }
+
+  getButton(page, content, key, active) {
+    return /*#__PURE__*/React.createElement(Button, _extends({
+      href: this.generateHref(page),
+      key: key,
+      active: active,
+      disabled: this.props.loader && !active && !this.props.loaderNavigation,
+      loader: this.props.loader && active
+    }, this.getClickProps(this.handlePageChange(page))), content);
+  }
+
+  getClickProps(onClick) {
+    const {
+      hrefFunc,
+      onPageChange
+    } = this.props;
+
+    if (!onPageChange) {
+      return {};
+    } else if (hrefFunc) {
+      return {
+        onPlainLeftClick: onClick
+      };
+    } else {
+      return {
+        onClick
+      };
+    }
+  }
+
+  getPageSizeSelector() {
+    const selectOptions = this.getSelectOptions();
+    return !this.props.disablePageSizeSelector && /*#__PURE__*/React.createElement("div", {
+      "data-test": "ring-pager-page-size-selector",
+      style: {
+        float: 'right'
+      }
+    }, /*#__PURE__*/React.createElement(Select, {
+      data: selectOptions.data,
+      selected: selectOptions.selected,
+      onSelect: this.handlePageSizeChange,
+      type: Select.Type.INLINE,
+      disabled: this.props.loader
+    }));
+  }
+
+  getPagerLinks() {
+    const prevLinkAvailable = this.props.currentPage !== 1;
+    const nextLinkAvailable = this.props.openTotal || this.props.currentPage !== this.getTotal();
+    const nextIcon = /*#__PURE__*/React.createElement(Icon, {
+      glyph: chevronRightIcon,
+      key: "icon"
+    });
+    const prevIcon = /*#__PURE__*/React.createElement(Icon, {
+      glyph: chevronLeftIcon,
+      key: "icon"
+    });
+    const prevText = this.props.translations.previousPage;
+    const nextText = this.props.translations.nextPage;
+
+    const nextLinkContent = WrapText => [/*#__PURE__*/React.createElement("span", {
+      key: "text"
+    }, /*#__PURE__*/React.createElement(WrapText, null, nextText)), nextIcon];
+
+    const prevLinkContent = WrapText => [prevIcon, /*#__PURE__*/React.createElement("span", {
+      key: "text"
+    }, /*#__PURE__*/React.createElement(WrapText, null, prevText))];
+
+    const prevLinkHref = this.generateHref(this.props.currentPage - 1);
+    const nextLinkHref = this.generateHref(this.props.currentPage + 1);
+    const disabledLinkClasses = classNames({
+      [modules_1a5f0d42.link]: true,
+      [modules_1a5f0d42.linkDisabled]: true
+    });
+    return /*#__PURE__*/React.createElement("div", {
+      className: modules_1a5f0d42.links
+    }, prevLinkAvailable && (!this.props.loader || this.props.loaderNavigation) ? /*#__PURE__*/React.createElement(Link, _extends({
+      href: prevLinkHref,
+      className: modules_1a5f0d42.link
+    }, this.getClickProps(this.handlePrevClick)), prevLinkContent) : /*#__PURE__*/React.createElement("span", {
+      className: disabledLinkClasses
+    }, prevIcon, /*#__PURE__*/React.createElement("span", {
+      key: "text"
+    }, prevText)), nextLinkAvailable && (!this.props.loader || this.props.loaderNavigation) ? /*#__PURE__*/React.createElement(Link, _extends({
+      href: nextLinkHref,
+      className: modules_1a5f0d42.link
+    }, this.getClickProps(this.handleNextClick)), nextLinkContent) : /*#__PURE__*/React.createElement("span", {
+      className: disabledLinkClasses
+    }, /*#__PURE__*/React.createElement("span", {
+      key: "text"
+    }, nextText), nextIcon));
+  }
+
+  generateHref(page) {
+    if (this.props.hrefFunc === undefined) {
+      return undefined;
+    }
+
+    const pageSize = this.props.disablePageSizeSelector ? undefined : this.props.pageSize;
+    return this.props.hrefFunc(page, pageSize);
+  }
+
+  getPagerContent() {
+    const {
+      currentPage,
+      visiblePagesLimit
+    } = this.props;
+    const totalPages = this.getTotal();
+
+    if (totalPages < 2 && !this.props.openTotal) {
+      return null;
+    }
+
+    let start = 1;
+    let end = totalPages; // eslint-disable-next-line no-magic-numbers
+
+    if (totalPages >= visiblePagesLimit + 6) {
+      const leftHalfFrameSize = Math.ceil(visiblePagesLimit / 2) - 1;
+      const rightHalfFrameSize = visiblePagesLimit - leftHalfFrameSize - 1;
+      start = currentPage - leftHalfFrameSize;
+      end = currentPage + rightHalfFrameSize;
+
+      if (start < 1) {
+        const tail = 1 - start;
+        start += tail;
+        end += tail;
+      }
+
+      if (end > totalPages) {
+        const tail = end - totalPages;
+        start -= tail;
+        end -= tail;
+      }
+
+      if (start < 1) {
+        start += 1 - start;
+      }
+    }
+
+    const buttons = [];
+
+    for (let i = start; i <= end; i++) {
+      buttons.push(this.getButton(i, i, i, i === currentPage));
+    }
+
+    const lastPageButtonAvailable = end < totalPages && !this.props.openTotal || this.props.openTotal && this.props.canLoadLastPageWithOpenTotal;
+    return /*#__PURE__*/React.createElement("div", null, this.getPagerLinks(), /*#__PURE__*/React.createElement(ButtonToolbar, null, start > 1 && /*#__PURE__*/React.createElement(ButtonGroup, null, this.getButton(1, this.props.translations.firstPage)), /*#__PURE__*/React.createElement(ButtonGroup, null, start > 1 && this.getButton(start - 1, '...'), buttons, end < totalPages && this.getButton(end + 1, '...'), end === totalPages && this.props.openTotal && /*#__PURE__*/React.createElement(Button, _extends({
+      href: this.generateHref(end + 1),
+      disabled: this.props.loader
+    }, this.getClickProps(this.handleLoadMore(end + 1))), '...')), lastPageButtonAvailable && /*#__PURE__*/React.createElement(ButtonGroup, null, this.getButton(this.props.openTotal ? -1 : totalPages, this.props.translations.lastPage))), this.getPageSizeSelector());
+  }
+
+  render() {
+    const classes = classNames(modules_1a5f0d42.pager, this.props.className);
+    return /*#__PURE__*/React.createElement("div", {
+      "data-test": "ring-pager",
+      className: classes
+    }, this.props.total > 1 ? this.getPagerContent() : this.getPageSizeSelector());
+  }
+
+}
+
+_defineProperty(Pager, "propTypes", {
+  total: PropTypes.number.isRequired,
+  currentPage: PropTypes.number,
+  pageSize: PropTypes.number,
+  pageSizes: PropTypes.arrayOf(PropTypes.number),
+  visiblePagesLimit: PropTypes.number,
+  disablePageSizeSelector: PropTypes.bool,
+  openTotal: PropTypes.bool,
+  canLoadLastPageWithOpenTotal: PropTypes.bool,
+  onPageChange: PropTypes.func,
+  onPageSizeChange: PropTypes.func,
+  onLoadPage: PropTypes.func,
+  className: PropTypes.string,
+  translations: PropTypes.object,
+  loader: PropTypes.bool,
+  loaderNavigation: PropTypes.bool,
+  hrefFunc: PropTypes.func //function which generates href for all pager's buttons based on pager state passed as a function parameter, either this function or onPageChange should be provided
+
+});
+
+_defineProperty(Pager, "defaultProps", {
+  currentPage: 1,
+  pageSize: 50,
+  // eslint-disable-next-line no-magic-numbers
+  pageSizes: [20, 50, 100],
+  visiblePagesLimit: 7,
+  disablePageSizeSelector: false,
+  openTotal: false,
+  canLoadLastPageWithOpenTotal: false,
+  translations: {
+    perPage: 'per page',
+    firstPage: 'First page',
+    lastPage: 'Last page',
+    nextPage: 'Next page',
+    previousPage: 'Previous'
+  },
+  loader: false,
+  loaderNavigation: false,
+  onPageSizeChange: () => {},
+  onLoadPage: () => {}
+});
+
+export { Pager as default };