@jetbrains/ring-ui 4.1.5 → 5.0.0-beta.2

package/components/code/code.jsx

@@ -0,0 +1,94 @@
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import highlight from 'highlight.js/lib/core';
+import normalizeIndent from '../global/normalize-indent';
+import trivialTemplateTag from '../global/trivial-template-tag';
+import memoize from '../global/memoize';
+import styles from './code.css';
+import highlightStyles from './highlight.css';
+function noop() { }
+const registerLanguage = memoize(async (language) => {
+    const languageExports = await import(
+    /* webpackChunkName: "highlight-[request]" */
+    `highlight.js/lib/languages/${language}`);
+    highlight.registerLanguage(language, languageExports.default);
+});
+/**
+ * @name Code
+ */
+export default class Code extends PureComponent {
+    static propTypes = {
+        className: PropTypes.string,
+        code: PropTypes.string.isRequired,
+        inline: PropTypes.bool,
+        softWrap: PropTypes.bool,
+        language: PropTypes.string,
+        replacer: PropTypes.func,
+        codeRef: PropTypes.oneOfType([
+            PropTypes.shape({ current: PropTypes.instanceOf(Element) }),
+            PropTypes.func
+        ])
+    };
+    static defaultProps = {
+        inline: false,
+        softWrap: false,
+        replacer: noop
+    };
+    componentDidMount() {
+        this.highlight();
+    }
+    componentDidUpdate() {
+        this.highlight();
+    }
+    code;
+    async highlight() {
+        const codeRef = this.codeRef;
+        if (codeRef == null) {
+            return;
+        }
+        const { language, inline, replacer } = this.props;
+        if (!inline) {
+            if (language != null && highlight.getLanguage(language) == null) {
+                await registerLanguage(language);
+            }
+            // @ts-expect-error https://github.com/highlightjs/highlight.js/issues/2945
+            highlight.highlightElement(codeRef);
+        }
+        replacer(codeRef);
+    }
+    get codeRef() {
+        const { codeRef } = this.props;
+        return !codeRef || typeof codeRef === 'function' ? this.code : codeRef.current;
+    }
+    get initCodeRef() {
+        const { codeRef } = this.props;
+        const isFunctionCodeRef = typeof codeRef === 'function';
+        if (codeRef && !isFunctionCodeRef) {
+            return codeRef;
+        }
+        return (ref) => {
+            this.code = ref;
+            if (isFunctionCodeRef) {
+                codeRef(this.code);
+            }
+        };
+    }
+    render() {
+        const { code, className, inline, softWrap, language } = this.props;
+        const Tag = inline ? 'span' : 'pre';
+        const classes = classNames(styles.code, className, language, {
+            [styles.inline]: inline,
+            [styles.softWrap]: softWrap
+        });
+        return (<Tag className={classes}>
+        <code 
+        // should be focusable because it can be scrollable
+        tabIndex={inline ? -1 : 0} ref={this.initCodeRef} className={highlightStyles.highlightContainer}>
+          {normalizeIndent(code)}
+        </code>
+      </Tag>);
+    }
+}
+const code = trivialTemplateTag((source) => <Code code={source}/>);
+export { code, highlight };

package/components/compiler-ng/compiler-ng.examples.js

@@ -2,7 +2,7 @@ import angular from 'angular';
 
 import angularDecorator, {APP_NAME} from '../../.storybook/angular-decorator';
 
-import CompilerNG from '@jetbrains/ring-ui/components/compiler-ng/compiler-ng';
+import CompilerNG from './compiler-ng';
 
 export default {
   title: 'Legacy Angular/Compiler Ng',

package/components/confirm/confirm.d.ts

@@ -0,0 +1,48 @@
+import React, { PureComponent, ReactNode } from 'react';
+import PropTypes from 'prop-types';
+export interface ConfirmProps {
+    text: string;
+    description: ReactNode;
+    show: boolean;
+    rejectOnEsc: boolean;
+    inProgress: boolean;
+    cancelIsDefault: boolean;
+    confirmLabel: string;
+    rejectLabel: string;
+    onConfirm: ((event: React.MouseEvent<HTMLButtonElement>) => void);
+    onReject: ((event?: React.MouseEvent<HTMLButtonElement>) => void);
+    className?: string | undefined;
+}
+/**
+ * @name Confirm
+ */
+export default class Confirm extends PureComponent<ConfirmProps> {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        text: PropTypes.Requireable<string>;
+        description: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        show: PropTypes.Requireable<boolean>;
+        rejectOnEsc: PropTypes.Requireable<boolean>;
+        inProgress: PropTypes.Requireable<boolean>;
+        cancelIsDefault: PropTypes.Requireable<boolean>;
+        confirmLabel: PropTypes.Requireable<string>;
+        rejectLabel: PropTypes.Requireable<string>;
+        onConfirm: PropTypes.Requireable<(...args: any[]) => any>;
+        onReject: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    static defaultProps: {
+        text: null;
+        description: null;
+        show: boolean;
+        rejectOnEsc: boolean;
+        inProgress: boolean;
+        cancelIsDefault: boolean;
+        confirmLabel: string;
+        rejectLabel: string;
+        onConfirm: () => void;
+        onReject: () => void;
+    };
+    onEscPress: () => void;
+    render(): JSX.Element;
+}
+export declare type ConfirmAttributes = JSX.LibraryManagedAttributes<typeof Confirm, ConfirmProps>;

package/components/confirm/confirm.jsx

@@ -0,0 +1,59 @@
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import Dialog from '../dialog/dialog';
+import Button from '../button/button';
+import { Content, Header } from '../island/island';
+import Panel from '../panel/panel';
+import styles from './confirm.css';
+/**
+ * @name Confirm
+ */
+export default class Confirm extends PureComponent {
+    static propTypes = {
+        className: PropTypes.string,
+        text: PropTypes.string,
+        description: PropTypes.node,
+        show: PropTypes.bool,
+        rejectOnEsc: PropTypes.bool,
+        inProgress: PropTypes.bool,
+        cancelIsDefault: PropTypes.bool,
+        confirmLabel: PropTypes.string,
+        rejectLabel: PropTypes.string,
+        onConfirm: PropTypes.func,
+        onReject: PropTypes.func
+    };
+    static defaultProps = {
+        text: null,
+        description: null,
+        show: false,
+        rejectOnEsc: true,
+        inProgress: false,
+        cancelIsDefault: false,
+        confirmLabel: 'OK',
+        rejectLabel: 'Cancel',
+        onConfirm: () => { },
+        onReject: () => { }
+    };
+    onEscPress = () => {
+        if (this.props.rejectOnEsc) {
+            this.props.onReject();
+        }
+    };
+    render() {
+        const { show, className, inProgress, cancelIsDefault, text, description, confirmLabel, rejectLabel, onConfirm, onReject } = this.props;
+        return (<Dialog label={text || (typeof description === 'string' ? description : undefined)} className={className} onEscPress={this.onEscPress} show={show} trapFocus data-test="ring-confirm">
+        {text && <Header>{text}</Header>}
+        <Content>
+          {description && <div className={styles.description}>{description}</div>}
+        </Content>
+        <Panel>
+          <Button data-test="confirm-ok-button" primary={!cancelIsDefault} loader={inProgress} disabled={inProgress} onClick={onConfirm}>
+            {confirmLabel}
+          </Button>
+          <Button data-test="confirm-reject-button" onClick={onReject} disabled={inProgress} primary={cancelIsDefault}>
+            {rejectLabel}
+          </Button>
+        </Panel>
+      </Dialog>);
+    }
+}

package/components/confirm-ng/confirm-ng.examples.js

@@ -2,9 +2,9 @@ import angular from 'angular';
 
 import angularDecorator, {APP_NAME} from '../../.storybook/angular-decorator';
 
-import {hideConfirm} from '@jetbrains/ring-ui/components/confirm-service/confirm-service';
+import {hideConfirm} from '../confirm-service/confirm-service';
 
-import ConfirmNG from '@jetbrains/ring-ui/components/confirm-ng/confirm-ng';
+import ConfirmNG from './confirm-ng';
 
 export default {
   title: 'Legacy Angular/Confirm Ng',

package/components/confirm-service/confirm-service.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+/**
+ * @name Confirm Service
+ */
+export declare const containerElement: HTMLDivElement;
+export interface ConfirmServiceParams {
+    text?: string | undefined;
+    description?: ReactNode;
+    cancelIsDefault?: boolean | undefined;
+    confirmLabel?: string | undefined;
+    rejectLabel?: string | undefined;
+    onBeforeConfirm?: (() => void) | undefined;
+}
+export default function confirm({ text, description, confirmLabel, rejectLabel, cancelIsDefault, onBeforeConfirm }: ConfirmServiceParams): Promise<void>;
+export declare function hideConfirm(): void;

package/components/confirm-service/confirm-service.jsx

@@ -0,0 +1,49 @@
+import React from 'react';
+import { render } from 'react-dom';
+import Confirm from '../confirm/confirm';
+/**
+ * @name Confirm Service
+ */
+export const containerElement = document.createElement('div');
+/**
+ * Renders Confirm into virtual node to skip maintaining container
+ */
+function renderConfirm(props) {
+    render(<Confirm {...props}/>, containerElement);
+}
+export default function confirm({ text, description, confirmLabel = 'OK', rejectLabel = 'Cancel', cancelIsDefault, onBeforeConfirm }) {
+    return new Promise((resolve, reject) => {
+        const props = {
+            text,
+            description,
+            confirmLabel,
+            rejectLabel,
+            cancelIsDefault,
+            show: true,
+            onConfirm: () => {
+                if (onBeforeConfirm) {
+                    renderConfirm({ ...props, inProgress: true });
+                    return Promise.resolve(onBeforeConfirm()).
+                        then(() => {
+                        renderConfirm({ ...props, show: false });
+                        resolve();
+                    }).
+                        catch(err => {
+                        renderConfirm({ ...props, show: false });
+                        reject(err);
+                    });
+                }
+                renderConfirm({ ...props, show: false });
+                return resolve();
+            },
+            onReject: () => {
+                renderConfirm({ ...props, show: false });
+                reject(new Error('Confirm(@jetbrains/ring-ui): null exception'));
+            }
+        };
+        renderConfirm(props);
+    });
+}
+export function hideConfirm() {
+    renderConfirm({ text: '', show: false });
+}

package/components/content-layout/content-layout.d.ts

@@ -0,0 +1,26 @@
+import { Component, HTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+export interface ContentLayoutProps extends HTMLAttributes<HTMLElement> {
+    responsive: boolean;
+    contentClassName?: string | null | undefined;
+}
+/**
+ * @name Content Layout
+ */
+export default class ContentLayout extends Component<ContentLayoutProps> {
+    static propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        className: PropTypes.Requireable<string>;
+        contentClassName: PropTypes.Requireable<string>;
+        responsive: PropTypes.Requireable<boolean>;
+    };
+    static defaultProps: {
+        responsive: boolean;
+    };
+    state: {
+        contentNode: null;
+    };
+    saveContentNode: (contentNode: HTMLElement | null) => void;
+    render(): JSX.Element;
+}
+export { default as Sidebar } from './sidebar';

package/components/content-layout/content-layout.jsx

@@ -0,0 +1,45 @@
+import React, { cloneElement, Component } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import Sidebar from './sidebar';
+import styles from './content-layout.css';
+/**
+ * @name Content Layout
+ */
+export default class ContentLayout extends Component {
+    static propTypes = {
+        children: PropTypes.node,
+        className: PropTypes.string,
+        contentClassName: PropTypes.string,
+        responsive: PropTypes.bool
+    };
+    static defaultProps = {
+        responsive: true
+    };
+    state = {
+        contentNode: null
+    };
+    saveContentNode = (contentNode) => {
+        this.setState({ contentNode });
+    };
+    render() {
+        const { children, className, contentClassName, responsive, ...restProps } = this.props;
+        const classes = classNames(styles.contentLayout, className, {
+            [styles.contentLayoutResponsive]: responsive
+        });
+        const contentClasses = classNames(styles.contentLayoutContent, contentClassName);
+        const childrenArray = React.Children.toArray(children);
+        const sidebarChild = childrenArray.filter((child) => child != null && typeof child === 'object' && 'type' in child && child.type === Sidebar)[0];
+        const sidebar = sidebarChild && cloneElement(sidebarChild, {
+            contentNode: this.state.contentNode
+        });
+        const contentChildren = childrenArray.filter(child => child !== sidebarChild);
+        return (<div {...restProps} className={classes}>
+        {sidebar}
+        <main className={contentClasses} ref={this.saveContentNode}>
+          {contentChildren}
+        </main>
+      </div>);
+    }
+}
+export { default as Sidebar } from './sidebar';

package/components/content-layout/sidebar.d.ts

@@ -0,0 +1,31 @@
+import { Component, HTMLAttributes } from 'react';
+import PropTypes from 'prop-types';
+import { Waypoint } from 'react-waypoint';
+export interface SidebarProps extends HTMLAttributes<HTMLElement> {
+    right?: boolean | null | undefined;
+    containerClassName?: string | null | undefined;
+    fixedClassName?: string | null | undefined;
+    contentNode?: HTMLElement | null | undefined;
+}
+export default class Sidebar extends Component<SidebarProps> {
+    static propTypes: {
+        right: PropTypes.Requireable<boolean>;
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        className: PropTypes.Requireable<string>;
+        containerClassName: PropTypes.Requireable<string>;
+        fixedClassName: PropTypes.Requireable<string>;
+        contentNode: PropTypes.Requireable<object>;
+    };
+    state: {
+        topIsOutside: boolean;
+        bottomIsOutside: boolean;
+        sidebarVisibleHeight: undefined;
+    };
+    sidebarNode?: HTMLElement | null;
+    handleTopWaypoint: ({ currentPosition }: Waypoint.CallbackArgs) => void;
+    handleBottomWaypoint: ({ currentPosition, waypointTop }: Waypoint.CallbackArgs) => void;
+    shouldUseFixation(): boolean;
+    shouldFixateBottom(): boolean;
+    sidebarRef: (node: HTMLElement | null) => void;
+    render(): JSX.Element;
+}

package/components/content-layout/sidebar.jsx

@@ -0,0 +1,76 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { Waypoint } from 'react-waypoint';
+import styles from './content-layout.css';
+const ABOVE = 'above';
+const INSIDE = 'inside';
+export default class Sidebar extends Component {
+    static propTypes = {
+        right: PropTypes.bool,
+        children: PropTypes.node,
+        className: PropTypes.string,
+        containerClassName: PropTypes.string,
+        fixedClassName: PropTypes.string,
+        contentNode: PropTypes.object
+    };
+    state = {
+        topIsOutside: true,
+        bottomIsOutside: true,
+        sidebarVisibleHeight: undefined
+    };
+    sidebarNode;
+    handleTopWaypoint = ({ currentPosition }) => {
+        this.setState({ topIsOutside: currentPosition === ABOVE });
+    };
+    handleBottomWaypoint = ({ currentPosition, waypointTop }) => {
+        this.setState({
+            sidebarVisibleHeight: waypointTop,
+            bottomIsOutside: currentPosition !== INSIDE
+        });
+    };
+    shouldUseFixation() {
+        const { contentNode } = this.props;
+        const { sidebarNode } = this;
+        if (!contentNode || !sidebarNode) {
+            return false;
+        }
+        return contentNode.offsetHeight >= sidebarNode.offsetHeight;
+    }
+    shouldFixateBottom() {
+        const { topIsOutside, bottomIsOutside } = this.state;
+        return !bottomIsOutside && topIsOutside && this.shouldUseFixation();
+    }
+    sidebarRef = (node) => {
+        this.sidebarNode = node;
+    };
+    render() {
+        const { right, children, className, containerClassName, fixedClassName, contentNode, ...restProps } = this.props;
+        const { topIsOutside, bottomIsOutside, sidebarVisibleHeight } = this.state;
+        const shouldFixateTop = bottomIsOutside && topIsOutside && this.shouldUseFixation();
+        const shouldFixateBottom = this.shouldFixateBottom();
+        const containerClasses = classNames(styles.sidebarContainer, containerClassName, {
+            [styles.sidebarContainerRight]: right
+        });
+        const classes = classNames(styles.sidebar, className, {
+            [styles.sidebarRight]: right,
+            [styles.sidebarFixedTop]: shouldFixateTop,
+            [styles.sidebarFixedBottom]: shouldFixateBottom,
+            [fixedClassName ?? '']: shouldFixateTop || shouldFixateBottom
+        });
+        const style = {
+            maxHeight: shouldFixateBottom && sidebarVisibleHeight ? `${sidebarVisibleHeight}px` : undefined
+        };
+        return (<aside className={containerClasses} ref={this.sidebarRef}>
+        <Waypoint onEnter={this.handleTopWaypoint} onLeave={this.handleTopWaypoint}/>
+
+        <div {...restProps} style={style} className={classes}>
+          {children}
+        </div>
+
+        <div className={styles.bottomMarker}>
+          <Waypoint onEnter={this.handleBottomWaypoint} onLeave={this.handleBottomWaypoint}/>
+        </div>
+      </aside>);
+    }
+}

package/components/contenteditable/contenteditable.d.ts

@@ -0,0 +1,47 @@
+import { Component, HTMLAttributes, Ref } from 'react';
+import PropTypes from 'prop-types';
+/**
+ * @name ContentEditable
+ */
+declare function noop(): void;
+export interface ContentEditableBaseProps extends HTMLAttributes<HTMLElement> {
+    disabled: boolean;
+    onComponentUpdate: ((prevProps: ContentEditableBaseProps) => void);
+    inputRef?: Ref<HTMLDivElement> | null | undefined;
+    __html: string;
+}
+declare class ContentEditableBase extends Component<ContentEditableBaseProps> {
+    static propTypes: {
+        __html: PropTypes.Requireable<string>;
+        disabled: PropTypes.Requireable<boolean>;
+        tabIndex: PropTypes.Requireable<number>;
+        componentDidUpdate: PropTypes.Requireable<(...args: any[]) => any>;
+        onComponentUpdate: PropTypes.Requireable<(...args: any[]) => any>;
+        className: PropTypes.Requireable<string>;
+        inputRef: PropTypes.Requireable<object>;
+    };
+    static defaultProps: {
+        disabled: boolean;
+        tabIndex: number;
+        onInput: typeof noop;
+        onComponentUpdate: typeof noop;
+    };
+    shouldComponentUpdate(nextProps: ContentEditableBaseProps): boolean;
+    componentDidUpdate(prevProps: ContentEditableBaseProps): void;
+    render(): JSX.Element;
+}
+declare type ContentEditableBaseAttrs = JSX.LibraryManagedAttributes<typeof ContentEditableBase, ContentEditableBaseProps>;
+export declare type ContentEditableProps = Omit<ContentEditableBaseAttrs, '__html'>;
+declare const ContentEditable: {
+    ({ children, ...props }: ContentEditableProps): JSX.Element;
+    propTypes: {
+        children: PropTypes.Requireable<PropTypes.ReactNodeLike>;
+        disabled: PropTypes.Requireable<boolean>;
+        tabIndex: PropTypes.Requireable<number>;
+        componentDidUpdate: PropTypes.Requireable<(...args: any[]) => any>;
+        onComponentUpdate: PropTypes.Requireable<(...args: any[]) => any>;
+        className: PropTypes.Requireable<string>;
+        inputRef: PropTypes.Requireable<object>;
+    };
+};
+export default ContentEditable;

package/components/contenteditable/contenteditable.jsx

@@ -0,0 +1,47 @@
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import { renderToStaticMarkup } from 'react-dom/server';
+/**
+ * @name ContentEditable
+ */
+function noop() { }
+const commonPropTypes = {
+    disabled: PropTypes.bool,
+    tabIndex: PropTypes.number,
+    componentDidUpdate: PropTypes.func,
+    onComponentUpdate: PropTypes.func,
+    className: PropTypes.string,
+    inputRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
+};
+class ContentEditableBase extends Component {
+    static propTypes = {
+        ...commonPropTypes,
+        __html: PropTypes.string
+    };
+    static defaultProps = {
+        disabled: false,
+        tabIndex: 0,
+        onInput: noop,
+        onComponentUpdate: noop
+    };
+    shouldComponentUpdate(nextProps) {
+        return nextProps.disabled !== this.props.disabled ||
+            nextProps.__html !== this.props.__html;
+    }
+    componentDidUpdate(prevProps) {
+        this.props.onComponentUpdate(prevProps);
+    }
+    render() {
+        const { __html, onComponentUpdate, disabled, tabIndex, inputRef, ...props } = this.props;
+        return (<div {...props} ref={inputRef} 
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        disabled={disabled} role="textbox" tabIndex={disabled ? undefined : tabIndex} contentEditable={!this.props.disabled} dangerouslySetInnerHTML={{ __html }}/>);
+    }
+}
+const ContentEditable = ({ children, ...props }) => <ContentEditableBase {...props} __html={renderToStaticMarkup(children)}/>;
+ContentEditable.propTypes = {
+    ...commonPropTypes,
+    children: PropTypes.node
+};
+export default ContentEditable;

package/components/data-list/data-list.d.ts

@@ -0,0 +1,89 @@
+/**
+  * @name Data List
+  */
+import React, { Component } from 'react';
+import { FocusSensorOuterProps } from '../global/focus-sensor-hoc';
+import { SelectionShortcutsAddProps, SelectionShortcutsOuterProps } from '../table/selection-shortcuts-hoc';
+import { DisableHoverAddProps } from '../table/disable-hover-hoc';
+import { SelectionItem } from '../table/selection';
+import { FormattedItem, moreLessButtonStates } from './item';
+export interface DataListBaseProps<T extends SelectionItem> {
+    data: readonly T[];
+    itemFormatter: (item: T) => FormattedItem<T>;
+    loading?: boolean | undefined;
+    onItemMoreLess?: ((item: T, more: boolean) => void) | undefined;
+    itemMoreLessState?: ((item: FormattedItem<T>) => moreLessButtonStates) | undefined;
+    remoteSelection?: boolean | undefined;
+    className?: string | null | undefined;
+    disabledHover?: boolean | null | undefined;
+}
+declare type FocusableProps<T extends SelectionItem> = DataListBaseProps<T> & DisableHoverAddProps & FocusSensorOuterProps<HTMLDivElement> & SelectionShortcutsAddProps<T>;
+export declare type DataListContainerProps<T extends SelectionItem> = DataListBaseProps<T> & FocusSensorOuterProps<HTMLDivElement> & SelectionShortcutsOuterProps<T>;
+export default class DataListContainer<T extends SelectionItem> extends Component<DataListContainerProps<T>> {
+    static propTypes: React.WeakValidationMap<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<SelectionItem, FocusableProps<SelectionItem>>> | undefined;
+    DataList: {
+        new (props: import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>> | Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>): {
+            state: {
+                disabledHover: boolean;
+            };
+            componentDidMount(): void;
+            componentWillUnmount(): void;
+            onMouseMove: () => void;
+            onKeyDown: (e: KeyboardEvent) => void;
+            render(): JSX.Element;
+            context: any;
+            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+            forceUpdate(callback?: (() => void) | undefined): void;
+            readonly props: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>> & Readonly<{
+                children?: React.ReactNode;
+            }>;
+            refs: {
+                [key: string]: React.ReactInstance;
+            };
+            shouldComponentUpdate?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextState: Readonly<{}>, nextContext: any): boolean;
+            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+            getSnapshotBeforeUpdate?(prevProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, prevState: Readonly<{}>): any;
+            componentDidUpdate?(prevProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, prevState: Readonly<{}>, snapshot?: any): void;
+            componentWillMount?(): void;
+            UNSAFE_componentWillMount?(): void;
+            componentWillReceiveProps?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextContext: any): void;
+            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextContext: any): void;
+            componentWillUpdate?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextState: Readonly<{}>, nextContext: any): void;
+            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextState: Readonly<{}>, nextContext: any): void;
+        };
+        new (props: import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>, context: any): {
+            state: {
+                disabledHover: boolean;
+            };
+            componentDidMount(): void;
+            componentWillUnmount(): void;
+            onMouseMove: () => void;
+            onKeyDown: (e: KeyboardEvent) => void;
+            render(): JSX.Element;
+            context: any;
+            setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+            forceUpdate(callback?: (() => void) | undefined): void;
+            readonly props: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>> & Readonly<{
+                children?: React.ReactNode;
+            }>;
+            refs: {
+                [key: string]: React.ReactInstance;
+            };
+            shouldComponentUpdate?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextState: Readonly<{}>, nextContext: any): boolean;
+            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+            getSnapshotBeforeUpdate?(prevProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, prevState: Readonly<{}>): any;
+            componentDidUpdate?(prevProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, prevState: Readonly<{}>, snapshot?: any): void;
+            componentWillMount?(): void;
+            UNSAFE_componentWillMount?(): void;
+            componentWillReceiveProps?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextContext: any): void;
+            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextContext: any): void;
+            componentWillUpdate?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextState: Readonly<{}>, nextContext: any): void;
+            UNSAFE_componentWillUpdate?(nextProps: Readonly<import("../table/disable-hover-hoc").DisableHoverProps<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>>>, nextState: Readonly<{}>, nextContext: any): void;
+        };
+        propTypes: React.WeakValidationMap<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>> | undefined;
+        defaultProps: Partial<import("../table/selection-shortcuts-hoc").SelectionShortcutsProps<T, FocusableProps<T>>> | undefined;
+        contextType?: React.Context<any> | undefined;
+    };
+    render(): JSX.Element;
+}
+export {};