@jetbrains/ring-ui 5.1.21 → 5.1.23

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

@@ -1,83 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,147 +0,0 @@
-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

@@ -1,74 +0,0 @@
-/// <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

@@ -1,191 +0,0 @@
-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

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

package/components/shortcuts/shortcut-title.js

@@ -1,50 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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;
-};