@jetbrains/ring-ui 4.1.1 → 4.1.2

package/dist/select-ng/select-ng__lazy.js

@@ -0,0 +1,150 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import angular from 'angular';
+import { render, hydrate } from 'react-dom';
+import React from 'react';
+import { RerenderableSelect } from '../select/select.js';
+import 'classnames';
+import 'prop-types';
+import '@jetbrains/icons/chevron-10px';
+import '@jetbrains/icons/close';
+import 'deep-equal';
+import '../dropdown/dropdown.js';
+import '../global/data-tests.js';
+import '../_helpers/anchor.js';
+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 '../button/button.js';
+import 'focus-visible';
+import '../global/theme.js';
+import '../link/clickableLink.js';
+import '../_helpers/button__classes.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';
+
+class SelectLazy {
+  constructor(container, props, ctrl, type) {
+    _defineProperty(this, "onClick", () => {
+      this._clickHandler();
+    });
+
+    this.container = container;
+    this.ctrl = ctrl;
+    this.props = props || {};
+    this.type = type;
+    this.node = container;
+    this._popup = {
+      isVisible: angular.noop
+    };
+    this.attachEvents();
+    this.render();
+  }
+
+  rerender() {
+    let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    for (const prop in props) {
+      if (props.hasOwnProperty(prop)) {
+        if (props[prop] == this.props[prop]) {
+          //eslint-disable-line eqeqeq
+          break;
+        }
+
+        this.render(props);
+        return;
+      }
+    }
+  }
+
+  attachEvents() {
+    this.container.addEventListener('click', this.onClick);
+  }
+
+  detachEvents() {
+    this.container.removeEventListener('click', this.onClick);
+  }
+
+  render(props) {
+    this.reactSelect = /*#__PURE__*/React.createElement(RerenderableSelect, Object.assign({}, this.props, props || {}));
+    this.props = this.reactSelect.props;
+
+    if (this.type !== 'dropdown') {
+      const ReactDOMServer = require('react-dom/server');
+
+      this.container.innerHTML = ReactDOMServer.renderToString(this.reactSelect);
+    }
+  }
+
+  _clickHandler() {
+    this.detachEvents();
+
+    if (this.type === 'dropdown') {
+      this.ctrl.selectInstance = render(this.reactSelect, this.container); // In "dropdown" mode we don't click select itself, so need to force click handler
+
+      this.ctrl.selectInstance._clickHandler();
+    } else {
+      this.ctrl.selectInstance = hydrate(this.reactSelect, this.container);
+    }
+  }
+
+}
+
+export { SelectLazy as default };

package/dist/select-ng/select-ng__options.js

@@ -0,0 +1,145 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import angular from 'angular';
+import deepEqual from 'deep-equal';
+
+class Options {
+  constructor(scope, optionsString) {
+    this.scope = scope;
+    const $parse = this.constructor.$parse;
+    const MATCHES = this.constructor.MATCHES;
+    let match;
+
+    if (!(match = optionsString.match(this.constructor.OPTIONS_REGEXP))) {
+      throw new Error('Bad rgSelect expression format. Expected: [{item}] [[as] item.text] [select as item.selectLabel]' + ` [describe as {item.description}] [for] {item} in {items|dataSource(query)} [track by item.id], Received: ${optionsString}`);
+    }
+    /**
+     * Now we can write only `item.value as item.label for item in items`
+     * we can not skip `item.label`
+     */
+
+
+    this.hasItemGetter = Boolean(match[MATCHES.ITEM] && match[MATCHES.LABEL]);
+    this.itemGetter = $parse(match[MATCHES.ITEM]);
+    this.labelGetter = match[MATCHES.LABEL] && $parse(match[MATCHES.LABEL]) || this.itemGetter;
+    this.selectedLabelGetter = match[MATCHES.SELECTED_LABEL] && $parse(match[MATCHES.SELECTED_LABEL]);
+    this.descriptionGetter = match[MATCHES.DESCRIPTION] && $parse(match[MATCHES.DESCRIPTION]);
+    this.optionVariableName = match[MATCHES.OPTION];
+    this.datasourceGetter = $parse(match[MATCHES.ITEMS]);
+    this.trackByGetter = match[MATCHES.TRACK] && $parse(match[MATCHES.TRACK]);
+    this.datasourceIsFunction = match[MATCHES.ITEMS].indexOf('(') > 0;
+  }
+
+  getProperty(option, getter) {
+    if (getter) {
+      const locals = {};
+      locals[this.optionVariableName] = option;
+      return getter.call(this, this.scope, locals);
+    }
+
+    return undefined;
+  }
+  /**
+   * @param {Object} option The item from options collection
+   * @return {any} The option value
+   */
+
+
+  getValue(option) {
+    if (!this.hasItemGetter) {
+      return option;
+    }
+
+    const value = this.getProperty(option, this.itemGetter);
+    return value === undefined ? option : value;
+  }
+  /**
+   * @param {any} value The option value
+   * @param {Array} options The list of options
+   * @return {Object|undefined} The option object
+   */
+
+
+  getOptionByValue(value, options) {
+    /**
+     * @param {any} it
+     * @return {string} The string representation of the value
+     */
+    function toString(it) {
+      return typeof it === 'object' ? JSON.stringify(it) : String(it);
+    }
+
+    if (!this.hasItemGetter) {
+      return value;
+    }
+
+    const matchedOptions = options.filter(option => {
+      const optionValue = this.getValue(option);
+
+      if (typeof value === 'object') {
+        return deepEqual(optionValue, value);
+      }
+
+      return optionValue === value;
+    });
+
+    if (matchedOptions.length > 1) {
+      throw new Error(`Error(rg-select): You can not have two options with same value(${toString(value)})`);
+    }
+
+    return matchedOptions[0];
+  }
+
+  getKey(option) {
+    return this.getProperty(option, this.trackByGetter) || option[this.constructor.defaultKeyField] || option;
+  }
+
+  getLabel(option) {
+    const optionStringValue = typeof option === 'string' ? option : null;
+    return this.getProperty(option, this.labelGetter) || option[this.constructor.defaultLabelField] || optionStringValue;
+  }
+
+  getSelectedLabel(option) {
+    return this.getProperty(option, this.selectedLabelGetter) || option[this.constructor.defaultSelectedLabelField];
+  }
+
+  getDescription(option) {
+    return this.getProperty(option, this.descriptionGetter) || option[this.constructor.defaultDescriptionField];
+  }
+
+  getOptions(query, skip) {
+    return this.datasourceGetter(this.scope, {
+      query,
+      skip
+    });
+  }
+
+}
+
+_defineProperty(Options, "OPTIONS_REGEXP", /^\s*(.*?)(?:\s+as\s+(.*?))?(?:\s+select\s+as\s+(.*?))?(?:\s+describe\sas\s+(.*?))?(?:\s+for\s+)?([$\w]+)\s+in\s+(.*?)(?:\s+track\sby\s+(.*?))?$/);
+
+_defineProperty(Options, "MATCHES", {
+  ITEM: 1,
+  LABEL: 2,
+  SELECTED_LABEL: 3,
+  DESCRIPTION: 4,
+  OPTION: 5,
+  ITEMS: 6,
+  TRACK: 7
+});
+
+_defineProperty(Options, "defaultKeyField", 'key');
+
+_defineProperty(Options, "defaultLabelField", 'label');
+
+_defineProperty(Options, "defaultSelectedLabelField", 'selectedLabel');
+
+_defineProperty(Options, "defaultDescriptionField", 'description');
+
+const angularModule = angular.module('Ring.select.options', []);
+angularModule.factory('SelectOptions', ["$parse", function SelectOptionsFactory($parse) {
+  Options.$parse = $parse;
+  return Options;
+}]);
+var SelectNgOptions = angularModule.name;
+
+export { SelectNgOptions as default };

package/dist/shortcuts/core.js

@@ -0,0 +1,245 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import Combokeys from 'combokeys';
+import sniffr from '../global/sniffer.js';
+import 'sniffr';
+
+class Shortcuts {
+  constructor() {
+    _defineProperty(this, "ALLOW_SHORTCUTS_SELECTOR", '.ring-js-shortcuts');
+
+    _defineProperty(this, "ROOT_SCOPE", {
+      scopeId: 'ROOT',
+      options: {}
+    });
+
+    _defineProperty(this, "_scopes", {});
+
+    _defineProperty(this, "combokeys", new Combokeys(document.documentElement));
+
+    _defineProperty(this, "trigger", combo => this.combokeys.trigger(combo));
+
+    _defineProperty(this, "_dispatcher", (e, key) => {
+      let currentScope;
+
+      for (let i = this._scopeChain.length - 1; i >= 0; i--) {
+        const scopeInChain = this._scopeChain[i];
+        currentScope = this._scopes[scopeInChain.scopeId];
+
+        if (currentScope && currentScope[key]) {
+          const ret = currentScope[key](e, key, scopeInChain.scopeId); // Fall down in chain when returning true
+
+          if (ret !== true) {
+            return ret;
+          }
+        }
+
+        if (scopeInChain.options.modal) {
+          return true;
+        }
+      }
+
+      return undefined;
+    });
+
+    _defineProperty(this, "_defaultFilter", (e, element, key) => {
+      // if the element or its parents have the class "ring-js-shortcuts" then no need to stop
+      if (element === document || element.matches(this.ALLOW_SHORTCUTS_SELECTOR) || (element.dataset.enabledShortcuts != null ? element.dataset.enabledShortcuts.split(',').includes(key) : element.closest(this.ALLOW_SHORTCUTS_SELECTOR) != null)) {
+        return false;
+      } // stop for input, select, and textarea
+
+
+      return element.matches('input,select,textarea') || element.contentEditable && element.contentEditable === 'true';
+    });
+
+    this.setFilter();
+    this.setScope();
+  }
+
+  /**
+   * Binds a handler to a shortcut
+   *
+   * @param params.key {string | Array.<string>) Keys to bind
+   * @param params.handler {Function} Events handle
+   * @param params.scope {string} Scope (optional)
+   * @param params.type {string} Event type, will be passed to Combokeys (optional)
+   */
+  bind(params) {
+    if (!(params instanceof Object) || typeof params.handler !== 'function') {
+      throw new Error('Shortcut handler should exist');
+    }
+
+    if (!params.scope) {
+      params.scope = this.ROOT_SCOPE.scopeId;
+    }
+
+    if (Array.isArray(params.key)) {
+      for (let i = 0; i < params.key.length; i++) {
+        this.bind(Object.assign({}, params, {
+          key: params.key[i]
+        }));
+      }
+
+      return;
+    }
+
+    if (typeof params.key !== 'string') {
+      throw new Error('Shortcut key should exist');
+    }
+
+    if (!this._scopes[params.scope]) {
+      this._scopes[params.scope] = {};
+    }
+
+    this._scopes[params.scope][params.key] = params.handler;
+    this.combokeys.bind(params.key, this._dispatcher, this._getKeyboardEventType(params));
+  }
+  /**
+   * Binds a map of shortcuts to handlers with common options
+   *
+   * @map {Object) Keys to handlers map
+   * @options.scope {string} Scope (optional)
+   * @options.type {string} Event type, will be passed to Combokeys (optional)
+   */
+
+
+  bindMap(map, options) {
+    if (!(map instanceof Object)) {
+      throw new Error('Shortcuts map shouldn\'t be empty');
+    }
+
+    for (const key in map) {
+      if (map.hasOwnProperty(key)) {
+        this.bind(Object.assign({}, options || {}, {
+          key,
+          handler: map[key]
+        }));
+      }
+    }
+  }
+
+  unbindScope(scope) {
+    this._scopes[scope] = null;
+  }
+
+  getScope() {
+    return this._scopeChain.slice(1);
+  }
+
+  hasScope(scopeId) {
+    return this.indexOfScope(scopeId) !== -1;
+  }
+  /**
+   * Adds a scope to the chain
+   * @param scopeId id of scope to add
+   * @param options options for pushing scope
+   * @param options.modal whether keys should fall through this scope or not.
+   * Useful for modals or overlays
+   */
+
+
+  pushScope(scopeId) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+    if (scopeId) {
+      const position = this.indexOfScope(scopeId);
+
+      if (position !== -1) {
+        this._scopeChain.splice(position, 1);
+      }
+
+      this._scopeChain.push(this.wrapScope(scopeId, options));
+    }
+  }
+
+  popScope(scopeId) {
+    if (scopeId) {
+      const position = this.indexOfScope(scopeId);
+
+      if (position !== -1) {
+        return this._scopeChain.splice(position, this._scopeChain.length - 1);
+      }
+    }
+
+    return undefined;
+  }
+
+  spliceScope(scopeId) {
+    if (scopeId) {
+      const position = this.indexOfScope(scopeId);
+
+      if (position !== -1) {
+        this._scopeChain.splice(position, 1);
+      }
+    }
+  }
+
+  setScope(scope) {
+    if (scope) {
+      let scopeChain;
+
+      if (typeof scope === 'string' || !Array.isArray(scope) && typeof scope === 'object' && scope !== null) {
+        scopeChain = [scope];
+      } else {
+        scopeChain = scope;
+      }
+
+      if (!Array.isArray(scopeChain)) {
+        return;
+      }
+
+      scopeChain = scopeChain.map(scopeItem => {
+        const isScopeId = typeof scopeItem === 'string';
+        return isScopeId ? this.wrapScope(scopeItem) : scopeItem;
+      });
+      this._scopeChain = [this.ROOT_SCOPE].concat(scopeChain);
+    } else {
+      this._scopeChain = [this.ROOT_SCOPE];
+    }
+  }
+
+  wrapScope(scopeId) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    return {
+      scopeId,
+      options
+    };
+  }
+
+  hasKey(key, scope) {
+    return !!(this._scopes[scope] && this._scopes[scope][key]);
+  }
+
+  _getKeyboardEventType(params) {
+    if (!params.type && sniffr.os.name === 'windows') {
+      const isSystemShortcut = params.key.match(/ctrl/i) && params.key.match(/shift/i) && params.key.match(/[0-9]/);
+      /**
+       * Windows system shortcuts (ctrl+shift+[0-9] are caught by the OS on 'keydown', so let's use 'keyup'
+       */
+
+      if (isSystemShortcut) {
+        return 'keyup';
+      }
+    }
+
+    return params.type;
+  }
+
+  setFilter(fn) {
+    this.combokeys.stopCallback = typeof fn === 'function' ? fn : this._defaultFilter;
+  }
+
+  indexOfScope(scopeId) {
+    return this._scopeChain.findIndex(scope => scope.scopeId === scopeId);
+  }
+
+  reset() {
+    this._scopes = {};
+    this.setScope();
+    this.combokeys.reset();
+  }
+
+}
+
+var shortcutsInstance = new Shortcuts();
+
+export { shortcutsInstance as default };

package/dist/shortcuts/shortcut-title.js

@@ -0,0 +1,51 @@
+import sniffr from '../global/sniffer.js';
+import 'sniffr';
+
+const macSymbolsMap = {
+  enter: '⏎',
+  shift: '⇧',
+  meta: '⌘',
+  mod: '⌘',
+  alt: '⌥',
+  ctrl: '⌃',
+  backspace: '⌫',
+  esc: 'Esc',
+  tab: 'Tab',
+  del: 'Del',
+  home: 'Home',
+  end: 'End',
+  space: 'Space',
+  ins: 'Insert',
+  left: '←',
+  up: '↑',
+  right: '→',
+  down: '↓'
+};
+const winSymbolsMap = {
+  enter: 'Enter',
+  shift: 'Shift',
+  meta: 'Ctrl',
+  mod: 'Ctrl',
+  alt: 'Alt',
+  ctrl: 'Ctrl',
+  backspace: 'Backspace',
+  esc: 'Esc',
+  tab: 'Tab',
+  del: 'Delete',
+  home: 'Home',
+  end: 'End',
+  space: 'Space',
+  ins: 'Insert',
+  left: '←',
+  up: '↑',
+  right: '→',
+  down: '↓'
+};
+function getShortcutTitle(shortcut) {
+  const MAC_OS = sniffr.os.name === 'macos';
+  const KEY_SEPARATOR = MAC_OS ? '' : '+';
+  const symbolsMap = MAC_OS ? macSymbolsMap : winSymbolsMap;
+  return shortcut.split(/\+/g).map(symbol => symbolsMap[symbol] || symbol.toUpperCase()).join(KEY_SEPARATOR);
+}
+
+export { getShortcutTitle };

package/dist/shortcuts/shortcuts-hoc.js

@@ -0,0 +1,41 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import React from 'react';
+import PropTypes from 'prop-types';
+import getUID from '../global/get-uid.js';
+import Shortcuts from './shortcuts.js';
+import './core.js';
+import 'combokeys';
+import '../global/sniffer.js';
+import 'sniffr';
+
+function shortcutsHOC(ComposedComponent) {
+  var _class, _temp;
+
+  return _temp = _class = class WithShortcuts extends React.Component {
+    constructor() {
+      super(...arguments);
+
+      _defineProperty(this, "_shortcutsScopeUid", getUID('rg-shortcuts-'));
+    }
+
+    render() {
+      const {
+        rgShortcutsOptions,
+        rgShortcutsMap,
+        ...props
+      } = this.props;
+      return /*#__PURE__*/React.createElement(Shortcuts, {
+        scope: this._shortcutsScopeUid,
+        map: rgShortcutsMap,
+        options: rgShortcutsOptions,
+        disabled: rgShortcutsOptions.disabled
+      }, /*#__PURE__*/React.createElement(ComposedComponent, props));
+    }
+
+  }, _defineProperty(_class, "propTypes", {
+    rgShortcutsOptions: PropTypes.object,
+    rgShortcutsMap: PropTypes.object
+  }), _temp;
+}
+
+export { shortcutsHOC as default };

package/dist/shortcuts/shortcuts.js

@@ -0,0 +1,72 @@
+import { _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import shortcutsInstance from './core.js';
+import 'combokeys';
+import '../global/sniffer.js';
+import 'sniffr';
+
+class Shortcuts extends PureComponent {
+  componentDidMount() {
+    if (!this.props.disabled) {
+      this.turnShorcutsOn();
+    }
+  }
+
+  componentDidUpdate(prevProps) {
+    const {
+      disabled
+    } = this.props;
+
+    if (!prevProps.disabled && disabled) {
+      this.turnShorcutsOff();
+    }
+
+    if (prevProps.disabled && !disabled) {
+      this.turnShorcutsOn();
+    }
+  }
+
+  componentWillUnmount() {
+    if (!this.props.disabled) {
+      this.turnShorcutsOff();
+    }
+  }
+
+  turnShorcutsOn() {
+    const {
+      map,
+      scope,
+      options
+    } = this.props;
+    shortcutsInstance.bindMap(map, this.props);
+    shortcutsInstance.pushScope(scope, options);
+  }
+
+  turnShorcutsOff() {
+    const {
+      scope
+    } = this.props;
+    shortcutsInstance.unbindScope(scope);
+    shortcutsInstance.spliceScope(scope);
+  }
+
+  render() {
+    return this.props.children || null;
+  }
+
+}
+
+_defineProperty(Shortcuts, "propTypes", {
+  map: PropTypes.object.isRequired,
+  scope: PropTypes.string.isRequired,
+  options: PropTypes.object,
+  disabled: PropTypes.bool,
+  children: PropTypes.node
+});
+
+_defineProperty(Shortcuts, "defaultProps", {
+  options: {}
+});
+
+export { Shortcuts as default };