@jetbrains/ring-ui 5.1.23 → 5.1.24

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

@@ -0,0 +1,203 @@
+import { d as _createClass, f as _extends, c as _classCallCheck, _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.object.assign.js';
+import angular from 'angular';
+import React, { cloneElement } from 'react';
+import { render, hydrate } from '../global/react-render-adapter.js';
+import { RerenderableSelect } from '../select/select.js';
+import 'core-js/modules/es.array.iterator.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.weak-map.js';
+import 'core-js/modules/web.dom-collections.iterator.js';
+import 'react-dom';
+import 'core-js/modules/es.array.index-of.js';
+import 'core-js/modules/es.array.reduce.js';
+import 'core-js/modules/es.string.trim.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.array.find.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.string.replace.js';
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/web.dom-collections.for-each.js';
+import 'core-js/modules/es.array.slice.js';
+import 'core-js/modules/es.object.values.js';
+import 'classnames';
+import 'prop-types';
+import '@jetbrains/icons/chevron-down';
+import '@jetbrains/icons/close-12px';
+import 'deep-equal';
+import '../dropdown/dropdown.js';
+import '../global/data-tests.js';
+import 'core-js/modules/es.object.entries.js';
+import '../global/typescript-utils.js';
+import '../_helpers/anchor.js';
+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 'core-js/modules/es.string.starts-with.js';
+import '../global/memoize.js';
+import 'core-js/modules/es.map.js';
+import '../button/button.js';
+import '../link/clickableLink.js';
+import '../global/controls-height.js';
+import '../_helpers/button__classes.js';
+import '../avatar/avatar.js';
+import '../global/url.js';
+import 'core-js/modules/es.string.match.js';
+import '../global/dom.js';
+import 'core-js/modules/es.string.split.js';
+import 'core-js/modules/es.set.js';
+import '../avatar/fallback-avatar.js';
+import 'core-js/modules/es.array.from.js';
+import '../global/get-uid.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import '../popup/popup.js';
+import '../global/schedule-raf.js';
+import '../shortcuts/shortcuts.js';
+import '../shortcuts/core.js';
+import 'core-js/modules/es.array.includes.js';
+import 'core-js/modules/es.string.includes.js';
+import 'core-js/modules/es.array.splice.js';
+import 'core-js/modules/es.array.find-index.js';
+import 'combokeys';
+import '../global/sniffer.js';
+import 'sniffr';
+import '../tab-trap/tab-trap.js';
+import '../popup/position.js';
+import 'core-js/modules/es.array.sort.js';
+import '../popup/popup.consts.js';
+import '../popup/popup.target.js';
+import '../list/list.js';
+import 'core-js/modules/es.symbol.js';
+import 'core-js/modules/es.symbol.description.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-14px';
+import '@jetbrains/icons/remove-14px';
+import '../global/prop-types.js';
+import '../global/composeRefs.js';
+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 '../i18n/i18n-context.js';
+import '../i18n/i18n.js';
+import '../control-label/control-label.js';
+import '../_helpers/control-label.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/loader-inline.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 SelectLazy = /*#__PURE__*/function () {
+  function SelectLazy(container, props, ctrl, type, selectRef) {
+    var _this = this;
+    _classCallCheck(this, SelectLazy);
+    _defineProperty(this, "onClick", function () {
+      _this._clickHandler();
+    });
+    this.container = container;
+    this.ctrl = ctrl;
+    this.props = props || {};
+    this.type = type;
+    this.node = container;
+    this.selectInstance = null;
+    this.selectRef = function (node) {
+      _this.selectInstance = node;
+      selectRef(node);
+    };
+    this._popup = {
+      isVisible: angular.noop
+    };
+    this.attachEvents();
+    this.render();
+  }
+  _createClass(SelectLazy, [{
+    key: "rerender",
+    value: function rerender() {
+      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      for (var prop in props) {
+        if (props.hasOwnProperty(prop)) {
+          if (props[prop] == this.props[prop]) {
+            //eslint-disable-line eqeqeq
+            break;
+          }
+          this.render(props);
+          return;
+        }
+      }
+    }
+  }, {
+    key: "attachEvents",
+    value: function attachEvents() {
+      this.container.addEventListener('click', this.onClick, {
+        capture: true
+      });
+    }
+  }, {
+    key: "detachEvents",
+    value: function detachEvents() {
+      this.container.removeEventListener('click', this.onClick, {
+        capture: true
+      });
+    }
+  }, {
+    key: "render",
+    value: function render(props) {
+      this.reactSelect = /*#__PURE__*/React.createElement(RerenderableSelect, _extends({}, Object.assign({}, this.props, props || {}), {
+        ref: this.selectRef
+      }));
+      this.props = this.reactSelect.props;
+      if (this.type !== 'dropdown') {
+        var ReactDOMServer = require('react-dom/server');
+        this.container.innerHTML = ReactDOMServer.renderToString(this.reactSelect);
+      }
+    }
+  }, {
+    key: "_clickHandler",
+    value: function _clickHandler() {
+      var _this2 = this;
+      this.detachEvents();
+      if (this.type === 'dropdown') {
+        render( /*#__PURE__*/cloneElement(this.reactSelect, {
+          ref: function ref(node) {
+            var _node$_openPopupIfClo;
+            _this2.selectRef(node);
+            node === null || node === void 0 || (_node$_openPopupIfClo = node._openPopupIfClosed) === null || _node$_openPopupIfClo === void 0 || _node$_openPopupIfClo.call(node);
+          }
+        }), this.container);
+      } else {
+        hydrate(this.reactSelect, this.container);
+      }
+    }
+  }]);
+  return SelectLazy;
+}();
+
+export { SelectLazy as default };

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

@@ -0,0 +1,144 @@
+import { _ as _defineProperty, d as _createClass, c as _classCallCheck } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.match.js';
+import 'core-js/modules/es.array.index-of.js';
+import 'core-js/modules/es.array.filter.js';
+import 'core-js/modules/es.object.to-string.js';
+import angular from 'angular';
+import deepEqual from 'deep-equal';
+
+var Options = /*#__PURE__*/function () {
+  function Options(scope, optionsString) {
+    _classCallCheck(this, Options);
+    this.scope = scope;
+    var $parse = this.constructor.$parse;
+    var MATCHES = this.constructor.MATCHES;
+    var 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: ".concat(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;
+  }
+  _createClass(Options, [{
+    key: "getProperty",
+    value: function getProperty(option, getter) {
+      if (getter) {
+        var 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
+     */
+  }, {
+    key: "getValue",
+    value: function getValue(option) {
+      if (!this.hasItemGetter) {
+        return option;
+      }
+      var 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
+     */
+  }, {
+    key: "getOptionByValue",
+    value: function getOptionByValue(value, options) {
+      var _this = this;
+      /**
+       * @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;
+      }
+      var matchedOptions = options.filter(function (option) {
+        var 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(".concat(toString(value), ")"));
+      }
+      return matchedOptions[0];
+    }
+  }, {
+    key: "getKey",
+    value: function getKey(option) {
+      return this.getProperty(option, this.trackByGetter) || option[this.constructor.defaultKeyField] || option;
+    }
+  }, {
+    key: "getLabel",
+    value: function getLabel(option) {
+      var optionStringValue = typeof option === 'string' ? option : null;
+      return this.getProperty(option, this.labelGetter) || option[this.constructor.defaultLabelField] || optionStringValue;
+    }
+  }, {
+    key: "getSelectedLabel",
+    value: function getSelectedLabel(option) {
+      return this.getProperty(option, this.selectedLabelGetter) || option[this.constructor.defaultSelectedLabelField];
+    }
+  }, {
+    key: "getDescription",
+    value: function getDescription(option) {
+      return this.getProperty(option, this.descriptionGetter) || option[this.constructor.defaultDescriptionField];
+    }
+  }, {
+    key: "getOptions",
+    value: function getOptions(query, skip) {
+      return this.datasourceGetter(this.scope, {
+        query,
+        skip
+      });
+    }
+  }]);
+  return Options;
+}();
+_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');
+var 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.d.ts

@@ -0,0 +1,74 @@
+/// <reference types="combokeys" />
+export interface ShortcutsScopeOptions {
+    modal?: boolean | null | undefined;
+}
+export interface ShortcutsScope {
+    scopeId: string;
+    options: ShortcutsScopeOptions;
+}
+type ShortcutsHandler = (e: KeyboardEvent, key: string, scopeId: string) => boolean | null | void;
+export interface ShortcutsOptions {
+    scope?: string | null | undefined;
+    type?: string | undefined;
+}
+export interface ShortcutsParams extends ShortcutsOptions {
+    key: string | string[];
+    handler: ShortcutsHandler;
+}
+export type ShortcutsMap = Record<string, ShortcutsHandler>;
+declare class Shortcuts {
+    ALLOW_SHORTCUTS_SELECTOR: string;
+    ROOT_SCOPE: {
+        scopeId: string;
+        options: {};
+    };
+    _scopes: Record<string, Record<string, ShortcutsHandler> | null>;
+    private _scopeChain;
+    combokeys: Combokeys.Combokeys;
+    trigger: (combo: string) => void;
+    constructor();
+    private _dispatcher;
+    /**
+     * 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: ShortcutsParams): void;
+    /**
+     * 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: ShortcutsMap, options?: ShortcutsOptions): void;
+    unbindScope(scope: string): void;
+    getScope(): ShortcutsScope[];
+    hasScope(scopeId: string): boolean;
+    /**
+     * 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: string, options?: ShortcutsScopeOptions): void;
+    popScope(scopeId: string): ShortcutsScope[] | undefined;
+    spliceScope(scopeId: string): void;
+    setScope(scope?: ShortcutsScope | string | (ShortcutsScope | string)[] | null | undefined): void;
+    wrapScope(scopeId: string, options?: ShortcutsScopeOptions): {
+        scopeId: string;
+        options: ShortcutsScopeOptions;
+    };
+    hasKey(key: string, scope: string): boolean;
+    private _defaultFilter;
+    private _getKeyboardEventType;
+    setFilter(fn?: (e: Event, element: Element, key?: string) => boolean): void;
+    indexOfScope(scopeId: string): number;
+    reset(): void;
+}
+declare const _default: Shortcuts;
+export default _default;

package/dist/shortcuts/core.js

@@ -0,0 +1,249 @@
+import { d as _createClass, c as _classCallCheck, _ as _defineProperty } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.includes.js';
+import 'core-js/modules/es.string.includes.js';
+import 'core-js/modules/es.object.assign.js';
+import 'core-js/modules/es.array.slice.js';
+import 'core-js/modules/es.array.splice.js';
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.array.concat.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.match.js';
+import 'core-js/modules/es.array.find-index.js';
+import Combokeys from 'combokeys';
+import sniffr from '../global/sniffer.js';
+import 'sniffr';
+
+var Shortcuts = /*#__PURE__*/function () {
+  function Shortcuts() {
+    var _this = this;
+    _classCallCheck(this, Shortcuts);
+    _defineProperty(this, "ALLOW_SHORTCUTS_SELECTOR", '.ring-js-shortcuts');
+    _defineProperty(this, "ROOT_SCOPE", {
+      scopeId: 'ROOT',
+      options: {}
+    });
+    _defineProperty(this, "_scopes", {});
+    _defineProperty(this, "_scopeChain", []);
+    _defineProperty(this, "combokeys", new Combokeys(document.documentElement));
+    _defineProperty(this, "trigger", function (combo) {
+      return _this.combokeys.trigger(combo);
+    });
+    _defineProperty(this, "_dispatcher", function (e, key) {
+      var currentScope;
+      for (var i = _this._scopeChain.length - 1; i >= 0; i--) {
+        var scopeInChain = _this._scopeChain[i];
+        currentScope = _this._scopes[scopeInChain.scopeId];
+        if (currentScope && key != null && currentScope[key]) {
+          var 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", function (e, element, key) {
+      // if the element or its parents have the class "ring-js-shortcuts" then no need to stop
+      if (element === document || !(element instanceof HTMLElement) || key == null || 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:not([type=checkbox]),select,textarea') || element.contentEditable === 'true';
+    });
+    this.setFilter();
+    this.setScope();
+  }
+  _createClass(Shortcuts, [{
+    key: "bind",
+    value:
+    /**
+     * 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)
+     */
+    function 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 (var 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');
+      }
+      var scope = this._scopes[params.scope];
+      if (!scope) {
+        scope = this._scopes[params.scope] = {};
+      }
+      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)
+     */
+  }, {
+    key: "bindMap",
+    value: function bindMap(map, options) {
+      if (!(map instanceof Object)) {
+        throw new Error('Shortcuts map shouldn\'t be empty');
+      }
+      for (var key in map) {
+        if (map.hasOwnProperty(key)) {
+          this.bind(Object.assign({}, options || {}, {
+            key,
+            handler: map[key]
+          }));
+        }
+      }
+    }
+  }, {
+    key: "unbindScope",
+    value: function unbindScope(scope) {
+      this._scopes[scope] = null;
+    }
+  }, {
+    key: "getScope",
+    value: function getScope() {
+      return this._scopeChain.slice(1);
+    }
+  }, {
+    key: "hasScope",
+    value: function 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
+     */
+  }, {
+    key: "pushScope",
+    value: function pushScope(scopeId) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (scopeId) {
+        var position = this.indexOfScope(scopeId);
+        if (position !== -1) {
+          this._scopeChain.splice(position, 1);
+        }
+        this._scopeChain.push(this.wrapScope(scopeId, options));
+      }
+    }
+  }, {
+    key: "popScope",
+    value: function popScope(scopeId) {
+      if (scopeId) {
+        var position = this.indexOfScope(scopeId);
+        if (position !== -1) {
+          return this._scopeChain.splice(position, this._scopeChain.length - 1);
+        }
+      }
+      return undefined;
+    }
+  }, {
+    key: "spliceScope",
+    value: function spliceScope(scopeId) {
+      if (scopeId) {
+        var position = this.indexOfScope(scopeId);
+        if (position !== -1) {
+          this._scopeChain.splice(position, 1);
+        }
+      }
+    }
+  }, {
+    key: "setScope",
+    value: function setScope(scope) {
+      var _this2 = this;
+      if (scope) {
+        var scopeChain;
+        if (typeof scope === 'string' || !Array.isArray(scope) && typeof scope === 'object' && scope !== null) {
+          scopeChain = [scope];
+        } else {
+          scopeChain = scope;
+        }
+        if (!Array.isArray(scopeChain)) {
+          return;
+        }
+        var scopes = scopeChain.map(function (scopeItem) {
+          var isScopeId = typeof scopeItem === 'string';
+          return isScopeId ? _this2.wrapScope(scopeItem) : scopeItem;
+        });
+        this._scopeChain = [this.ROOT_SCOPE].concat(scopes);
+      } else {
+        this._scopeChain = [this.ROOT_SCOPE];
+      }
+    }
+  }, {
+    key: "wrapScope",
+    value: function wrapScope(scopeId) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return {
+        scopeId,
+        options
+      };
+    }
+  }, {
+    key: "hasKey",
+    value: function hasKey(key, scope) {
+      var _this$_scopes$scope;
+      return !!((_this$_scopes$scope = this._scopes[scope]) !== null && _this$_scopes$scope !== void 0 && _this$_scopes$scope[key]);
+    }
+  }, {
+    key: "_getKeyboardEventType",
+    value: function _getKeyboardEventType(params) {
+      if (!params.type && sniffr.os.name === 'windows') {
+        var isSystemShortcut = typeof params.key === 'string' && 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;
+    }
+  }, {
+    key: "setFilter",
+    value: function setFilter(fn) {
+      this.combokeys.stopCallback = typeof fn === 'function' ? fn : this._defaultFilter;
+    }
+  }, {
+    key: "indexOfScope",
+    value: function indexOfScope(scopeId) {
+      return this._scopeChain.findIndex(function (scope) {
+        return scope.scopeId === scopeId;
+      });
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      this._scopes = {};
+      this.setScope();
+      this.combokeys.reset();
+    }
+  }]);
+  return Shortcuts;
+}();
+var shortcuts = new Shortcuts();
+
+export { shortcuts as default };

package/dist/shortcuts/shortcut-title.d.ts

@@ -0,0 +1 @@
+export declare function getShortcutTitle(shortcut: string): string;