@jetbrains/ring-ui-built 6.0.1

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,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/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,56 @@
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.regexp.exec.js';
+import 'core-js/modules/es.string.split.js';
+import sniffr from '../global/sniffer.js';
+import 'sniffr';
+
+var 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: '↓'
+};
+var 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) {
+  var MAC_OS = sniffr.os.name === 'macos';
+  var KEY_SEPARATOR = MAC_OS ? '' : '+';
+  var symbolsMap = MAC_OS ? macSymbolsMap : winSymbolsMap;
+  return shortcut.split(/\+/g).map(function (symbol) {
+    return symbolsMap[symbol] || symbol.toUpperCase();
+  }).join(KEY_SEPARATOR);
+}
+
+export { getShortcutTitle };

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;
+};

package/components/shortcuts/shortcuts-hoc.js

@@ -0,0 +1,61 @@
+import { a as _inherits, b as _createSuper, d as _createClass, _ as _defineProperty, c as _classCallCheck, k as _assertThisInitialized, e as _objectWithoutProperties } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.concat.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/modules/es.object.to-string.js';
+import 'core-js/modules/es.regexp.to-string.js';
+import 'core-js/modules/es.array.map.js';
+import './core.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.regexp.exec.js';
+import 'core-js/modules/es.string.match.js';
+import 'core-js/modules/es.array.find-index.js';
+import 'combokeys';
+import '../global/sniffer.js';
+import 'sniffr';
+
+var _excluded = ["rgShortcutsOptions", "rgShortcutsMap"];
+function shortcutsHOC(ComposedComponent) {
+  var _class;
+  return _class = /*#__PURE__*/function (_React$Component) {
+    _inherits(WithShortcuts, _React$Component);
+    var _super = _createSuper(WithShortcuts);
+    function WithShortcuts() {
+      var _this;
+      _classCallCheck(this, WithShortcuts);
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      _this = _super.call.apply(_super, [this].concat(args));
+      _defineProperty(_assertThisInitialized(_this), "_shortcutsScopeUid", getUID('rg-shortcuts-'));
+      return _this;
+    }
+    _createClass(WithShortcuts, [{
+      key: "render",
+      value: function render() {
+        var _this$props = this.props,
+          rgShortcutsOptions = _this$props.rgShortcutsOptions,
+          rgShortcutsMap = _this$props.rgShortcutsMap,
+          props = _objectWithoutProperties(_this$props, _excluded);
+        return /*#__PURE__*/React.createElement(Shortcuts, {
+          scope: this._shortcutsScopeUid,
+          map: rgShortcutsMap,
+          options: rgShortcutsOptions,
+          disabled: rgShortcutsOptions.disabled
+        }, /*#__PURE__*/React.createElement(ComposedComponent, props));
+      }
+    }]);
+    return WithShortcuts;
+  }(React.Component), _defineProperty(_class, "propTypes", {
+    rgShortcutsOptions: PropTypes.object,
+    rgShortcutsMap: PropTypes.object
+  }), _class;
+}
+
+export { shortcutsHOC as default };

package/components/shortcuts/shortcuts.d.ts

@@ -0,0 +1,28 @@
+import { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import { ShortcutsMap, ShortcutsScopeOptions } from './core';
+export interface ShortcutsProps {
+    map: ShortcutsMap;
+    scope: string;
+    options: ShortcutsScopeOptions;
+    children?: React.ReactNode;
+    disabled?: boolean | null | undefined;
+}
+export default class Shortcuts extends PureComponent<ShortcutsProps> {
+    static propTypes: {
+        map: PropTypes.Validator<object>;
+        scope: PropTypes.Validator<string>;
+        options: PropTypes.Requireable<object>;
+        disabled: PropTypes.Requireable<boolean>;
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+    };
+    static defaultProps: {
+        options: {};
+    };
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: ShortcutsProps): void;
+    componentWillUnmount(): void;
+    turnShorcutsOn(): void;
+    turnShorcutsOff(): void;
+    render(): string | number | true | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | Iterable<import("react").ReactNode> | null;
+}

package/components/shortcuts/shortcuts.js

@@ -0,0 +1,92 @@
+import { _ as _defineProperty, a as _inherits, b as _createSuper, c as _classCallCheck, d as _createClass } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.map.js';
+import { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import shortcuts from './core.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.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';
+import '../global/sniffer.js';
+import 'sniffr';
+
+var Shortcuts = /*#__PURE__*/function (_PureComponent) {
+  _inherits(Shortcuts, _PureComponent);
+  var _super = _createSuper(Shortcuts);
+  function Shortcuts() {
+    _classCallCheck(this, Shortcuts);
+    return _super.apply(this, arguments);
+  }
+  _createClass(Shortcuts, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      if (!this.props.disabled) {
+        this.turnShorcutsOn();
+      }
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      var _this$props = this.props,
+        disabled = _this$props.disabled,
+        map = _this$props.map;
+      if (!prevProps.disabled && disabled) {
+        this.turnShorcutsOff();
+      }
+      if (prevProps.disabled && !disabled) {
+        this.turnShorcutsOn();
+      }
+      if (prevProps.map !== map) {
+        shortcuts.bindMap(map, this.props);
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (!this.props.disabled) {
+        this.turnShorcutsOff();
+      }
+    }
+  }, {
+    key: "turnShorcutsOn",
+    value: function turnShorcutsOn() {
+      var _this$props2 = this.props,
+        map = _this$props2.map,
+        scope = _this$props2.scope,
+        options = _this$props2.options;
+      shortcuts.bindMap(map, this.props);
+      shortcuts.pushScope(scope, options);
+    }
+  }, {
+    key: "turnShorcutsOff",
+    value: function turnShorcutsOff() {
+      var scope = this.props.scope;
+      shortcuts.unbindScope(scope);
+      shortcuts.spliceScope(scope);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return this.props.children || null;
+    }
+  }]);
+  return Shortcuts;
+}(PureComponent);
+_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 };

package/components/storage/storage.d.ts

@@ -0,0 +1,18 @@
+export interface StorageConfig {
+    type?: 'local' | 'session' | null | undefined;
+    cookieName?: string | null | undefined;
+    checkDelay?: number | null | undefined;
+}
+export interface StorageInterface {
+    get<T>(name: string): Promise<T | null>;
+    set<T>(name: string, value: T | null): Promise<T | null>;
+    remove(name: string): Promise<void>;
+    each<R>(callback: (item: string, value: unknown) => R | Promise<R>): Promise<R[]>;
+    on<T>(name: string, callback: (value: T | null) => void): () => void;
+}
+export interface StorageClass {
+    new (config?: StorageConfig | undefined): StorageInterface;
+    QUOTA?: number;
+}
+declare const ActualStorage: StorageClass;
+export default ActualStorage;