@jetbrains/ring-ui 5.1.23 → 5.1.24

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

@@ -0,0 +1,83 @@
+import angular from 'angular';
+
+import React, {cloneElement} from 'react';
+
+import {render, hydrate} from '../global/react-render-adapter';
+import {RerenderableSelect} from '../select/select';
+
+class SelectLazy {
+  constructor(container, props, ctrl, type, selectRef) {
+    this.container = container;
+    this.ctrl = ctrl;
+    this.props = props || {};
+    this.type = type;
+    this.node = container;
+    this.selectInstance = null;
+    this.selectRef = node => {
+      this.selectInstance = node;
+      selectRef(node);
+    };
+    this._popup = {
+      isVisible: angular.noop
+    };
+
+    this.attachEvents();
+    this.render();
+  }
+
+  onClick = () => {
+    this._clickHandler();
+  };
+
+  rerender(props = {}) {
+    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, {capture: true});
+  }
+
+  detachEvents() {
+    this.container.removeEventListener('click', this.onClick, {capture: true});
+  }
+
+  render(props) {
+    this.reactSelect = (
+      <RerenderableSelect
+        {...Object.assign({}, this.props, props || {})}
+        ref={this.selectRef}
+      />
+    );
+    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') {
+      render(cloneElement(this.reactSelect, {
+        ref: node => {
+          this.selectRef(node);
+          node?._openPopupIfClosed?.();
+        }
+      }), this.container);
+    } else {
+      hydrate(this.reactSelect, this.container);
+    }
+  }
+}
+
+export default SelectLazy;

package/components/select-ng/select-ng__lazy.test.js

@@ -0,0 +1,81 @@
+import SelectLazy from './select-ng__lazy';
+
+describe('Select Lazy', () => {
+
+
+  let containerNode;
+  let ctrl;
+  beforeEach(() => {
+    containerNode = document.createElement('div');
+    ctrl = {};
+  });
+
+
+  it('should create lazy select', () => {
+    const lazySelect = renderLazySelect();
+    lazySelect.should.not.be.undefined;
+  });
+
+
+  it('should render static markup', () => {
+    renderLazySelect();
+    should.exist(findSelectNode(containerNode));
+  });
+
+
+  it('should render react select on click', () => {
+    const lazySelect = renderLazySelect();
+    simulateClick(lazySelect);
+    ctrl.selectInstance.should.not.be.undefined;
+  });
+
+
+  it('should detach lazy select after render', () => {
+    const lazySelect = renderLazySelect();
+    sandbox.spy(lazySelect, '_clickHandler');
+
+    simulateClick(lazySelect);
+    simulateClick(lazySelect);
+    simulateClick(lazySelect);
+
+    lazySelect._clickHandler.should.be.calledOnce;
+  });
+
+
+  it('should not render markup for select dropdown', () => {
+    renderDropdownSelect();
+    should.not.exist(findSelectNode(containerNode));
+  });
+
+
+  it('should render select dropdown on click', () => {
+    const lazySelect = renderDropdownSelect();
+    simulateClick(lazySelect);
+    should.exist(ctrl.selectInstance);
+  });
+
+
+  function simulateClick(select) {
+    const clickEvent = new CustomEvent('click');
+    select.container.dispatchEvent(clickEvent);
+  }
+
+
+  function renderDropdownSelect() {
+    return renderLazySelect('dropdown');
+  }
+
+
+  function renderLazySelect(type = 'button') {
+    const lazySelect = new SelectLazy(containerNode, {}, ctrl, type, instance => {
+      ctrl.selectInstance = instance;
+    });
+    lazySelect.render();
+    return lazySelect;
+  }
+
+
+  function findSelectNode(container) {
+    return container.querySelector('[data-test="ring-select"]');
+  }
+});

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

@@ -0,0 +1,147 @@
+import angular from 'angular';
+
+import deepEqual from 'deep-equal';
+
+class Options {
+  static 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+(.*?))?$/;
+
+  static MATCHES = {
+    ITEM: 1,
+    LABEL: 2,
+    SELECTED_LABEL: 3,
+    DESCRIPTION: 4,
+    OPTION: 5,
+    ITEMS: 6,
+    TRACK: 7
+  };
+
+  static defaultKeyField = 'key';
+  static defaultLabelField = 'label';
+  static defaultSelectedLabelField = 'selectedLabel';
+  static defaultDescriptionField = 'description';
+
+  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});
+  }
+}
+
+
+const angularModule = angular.module('Ring.select.options', []);
+
+angularModule.factory('SelectOptions', function SelectOptionsFactory($parse) {
+  Options.$parse = $parse;
+  return Options;
+});
+
+export default angularModule.name;

package/components/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/components/shortcuts/core.js

@@ -0,0 +1,191 @@
+import Combokeys from 'combokeys';
+import sniffr from '../global/sniffer';
+class Shortcuts {
+    ALLOW_SHORTCUTS_SELECTOR = '.ring-js-shortcuts';
+    ROOT_SCOPE = {
+        scopeId: 'ROOT',
+        options: {}
+    };
+    _scopes = {};
+    _scopeChain = [];
+    combokeys = new Combokeys(document.documentElement);
+    trigger = (combo) => this.combokeys.trigger(combo);
+    constructor() {
+        this.setFilter();
+        this.setScope();
+    }
+    _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 && key != null && 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;
+    };
+    /**
+     * 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');
+        }
+        let 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)
+     */
+    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, options = {}) {
+        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;
+            }
+            const scopes = scopeChain.map(scopeItem => {
+                const isScopeId = typeof scopeItem === 'string';
+                return isScopeId ? this.wrapScope(scopeItem) : scopeItem;
+            });
+            this._scopeChain = [this.ROOT_SCOPE].concat(scopes);
+        }
+        else {
+            this._scopeChain = [this.ROOT_SCOPE];
+        }
+    }
+    wrapScope(scopeId, options = {}) {
+        return { scopeId, options };
+    }
+    hasKey(key, scope) {
+        return !!(this._scopes[scope]?.[key]);
+    }
+    _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 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');
+    };
+    _getKeyboardEventType(params) {
+        if (!params.type && sniffr.os.name === 'windows') {
+            const 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;
+    }
+    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();
+    }
+}
+export default new Shortcuts();

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

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

package/components/shortcuts/shortcut-title.js

@@ -0,0 +1,50 @@
+import sniffer from '../global/sniffer';
+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: '↓'
+};
+export function getShortcutTitle(shortcut) {
+    const MAC_OS = sniffer.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);
+}

package/components/shortcuts/shortcuts-hoc.d.ts

@@ -0,0 +1,65 @@
+import React, { ComponentType } from 'react';
+import PropTypes from 'prop-types';
+import { ShortcutsMap, ShortcutsScopeOptions } from './core';
+export interface ShortcutsHOCOptions extends ShortcutsScopeOptions {
+    disabled?: boolean | null | undefined;
+}
+export interface ShortcutsHOCProps {
+    rgShortcutsOptions: ShortcutsHOCOptions;
+    rgShortcutsMap: ShortcutsMap;
+}
+export default function shortcutsHOC<P extends {}>(ComposedComponent: ComponentType<P> | string): {
+    new (props: (P & ShortcutsHOCProps) | Readonly<P & ShortcutsHOCProps>): {
+        _shortcutsScopeUid: string;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<P & ShortcutsHOCProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<P & ShortcutsHOCProps>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<P & ShortcutsHOCProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<P & ShortcutsHOCProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<P & ShortcutsHOCProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<P & ShortcutsHOCProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P & ShortcutsHOCProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<P & ShortcutsHOCProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<P & ShortcutsHOCProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: P & ShortcutsHOCProps, context: any): {
+        _shortcutsScopeUid: string;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<P & ShortcutsHOCProps>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<P & ShortcutsHOCProps>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        componentDidMount?(): void;
+        shouldComponentUpdate?(nextProps: Readonly<P & ShortcutsHOCProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<P & ShortcutsHOCProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<P & ShortcutsHOCProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<P & ShortcutsHOCProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<P & ShortcutsHOCProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<P & ShortcutsHOCProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<P & ShortcutsHOCProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    propTypes: {
+        rgShortcutsOptions: PropTypes.Requireable<object>;
+        rgShortcutsMap: PropTypes.Requireable<object>;
+    };
+    contextType?: React.Context<any> | undefined;
+};