@jetbrains/ring-ui 4.1.4 → 5.0.0-beta.1

package/components/table/selection.d.ts

@@ -0,0 +1,47 @@
+export interface SelectionItem {
+    id: string | number;
+    [key: string]: unknown;
+}
+export interface TableSelectionConfig<T extends SelectionItem> {
+    data?: readonly T[] | undefined;
+    selected?: Set<T> | undefined;
+    focused?: T | null | undefined;
+    getKey?: ((item: T) => string | number) | undefined;
+    isItemSelectable?: ((item: T) => boolean | undefined) | undefined;
+    getChildren?: ((item: T) => readonly T[]) | undefined;
+}
+export interface CloneWithConfig<T> {
+    data?: readonly T[] | null | undefined;
+    selected?: Set<T> | readonly T[] | null | undefined;
+    focused?: T | null | undefined;
+}
+export default class Selection<T extends SelectionItem> {
+    private _rawData;
+    protected _getChildren: ((item: T) => readonly T[]);
+    protected _data: Set<T>;
+    protected _selected: Set<T>;
+    protected _focused: T | null;
+    private _getKey;
+    protected _isItemSelectable: (item: T) => boolean | undefined;
+    constructor({ data, selected, focused, getKey, getChildren, isItemSelectable }?: TableSelectionConfig<T>);
+    protected _buildData(data: readonly T[] | null | undefined): Set<T>;
+    protected _buildSelected(data: Set<T>, selected: Set<T>): Set<T>;
+    cloneWith({ data, selected, focused }: CloneWithConfig<T>): Selection<T>;
+    focus(value: T | null | undefined): Selection<T>;
+    moveUp(): Selection<T> | undefined;
+    moveDown(): Selection<T> | undefined;
+    moveStart(): Selection<T> | undefined;
+    moveEnd(): Selection<T> | undefined;
+    select(value?: T | null): Selection<T>;
+    deselect(value?: T | null): Selection<T>;
+    toggleSelection(value?: T | null): Selection<T>;
+    selectAll(): Selection<T>;
+    resetFocus(): Selection<T>;
+    resetSelection(): Selection<T>;
+    reset(): Selection<T>;
+    isFocused(value: T | null): boolean;
+    isSelected(value: T | null): boolean;
+    getFocused(): T | null;
+    getSelected(): Set<T>;
+    getActive(): Set<T>;
+}

package/components/table/selection.js

@@ -1,185 +1,150 @@
 export default class Selection {
-  constructor({
-    data = [],
-    selected = new Set(),
-    focused = null,
-    getKey = item => item.id,
-    getChildren = () => [],
-    isItemSelectable = () => true
-  } = {}) {
-    this._rawData = data;
-    this._getChildren = getChildren;
-
-    this._data = this._buildData(data);
-
-    this._selected = selected;
-    this._focused = focused;
-    this._getKey = getKey;
-    this._isItemSelectable = isItemSelectable;
-  }
-
-  _buildData(data) {
-    return new Set(data);
-  }
-
-  _buildSelected(data, selected) {
-    return new Set(selected);
-  }
-
-  cloneWith({data, selected, focused}) {
-    const newData = data || this._rawData;
-
-    let newSelected;
-    if (data && !selected) {
-      newSelected = new Set([...this._buildData(newData)].
-        filter(item => [...this._selected].some(it => this._getKey(item) === this._getKey(it))));
-      newSelected = this._buildSelected(this._buildData(newData), newSelected);
-    } else if (selected) {
-      newSelected = selected;
-    } else {
-      newSelected = this._selected;
-    }
-    newSelected = new Set([...newSelected].filter(item => this._isItemSelectable(item)));
-
-    const cloneFocus = () => [...this._buildData(data)].filter(
-      item => this._focused && this._getKey(item) === this._getKey(this._focused)
-    )[0];
-
-    const newFocused = focused === undefined ? this._focused : focused;
-
-    return new this.constructor({
-      data: newData,
-      selected: newSelected,
-      focused: (data && !focused) ? cloneFocus() : newFocused,
-      getKey: this._getKey,
-      getChildren: this._getChildren,
-      isItemSelectable: this._isItemSelectable
-    });
-  }
-
-  focus(value) {
-    return this.cloneWith({focused: value});
-  }
-
-  moveUp() {
-    const focused = this._focused;
-    const data = [...this._data];
-
-    if (!focused) {
-      return this.cloneWith({focused: data[data.length - 1]});
-    }
-
-    const nextItem = data[data.indexOf(focused) - 1];
-    if (nextItem) {
-      return this.cloneWith({focused: nextItem});
-    }
-
-    return undefined;
-  }
-
-  moveDown() {
-    const focused = this._focused;
-    const data = [...this._data];
-
-    if (!focused) {
-      return this.cloneWith({focused: data[0]});
-    }
-
-    const nextItem = data[data.indexOf(focused) + 1];
-    if (nextItem) {
-      return this.cloneWith({focused: nextItem});
-    }
-
-    return undefined;
-  }
-
-  moveStart() {
-    const data = [...this._data];
-
-    if (data.length) {
-      return this.cloneWith({focused: data[0]});
-    }
-
-    return undefined;
-  }
-
-  moveEnd() {
-    const data = [...this._data];
-
-    if (data.length) {
-      return this.cloneWith({focused: data.pop()});
-    }
-
-    return undefined;
-  }
-
-  select(value = this._focused) {
-    if (!value || !this._isItemSelectable(value)) {
-      return this;
-    }
-
-    const selected = new Set(this._selected);
-    selected.add(value);
-    return this.cloneWith({selected});
-  }
-
-  deselect(value = this._focused) {
-    if (!value || !this._isItemSelectable(value)) {
-      return this;
-    }
-
-    const selected = new Set(this._selected);
-    selected.delete(value);
-    return this.cloneWith({selected});
-  }
-
-  toggleSelection(value = this._focused) {
-    if (this.isSelected(value)) {
-      return this.deselect(value);
-    } else {
-      return this.select(value);
-    }
-  }
-
-  selectAll() {
-    return this.cloneWith({selected: [...this._data]});
-  }
-
-  resetFocus() {
-    return this.cloneWith({focused: null});
-  }
-
-  resetSelection() {
-    return this.cloneWith({selected: new Set()});
-  }
-
-  reset() {
-    return this.resetFocus().resetSelection();
-  }
-
-  isFocused(value) {
-    return this._focused === value;
-  }
-
-  isSelected(value) {
-    return this._selected.has(value);
-  }
-
-  getFocused() {
-    return this._focused;
-  }
-
-  getSelected() {
-    return new Set(this._selected);
-  }
-
-  getActive() {
-    if (this._selected.size) {
-      return new Set(this._selected);
-    } else if (this._focused) {
-      return new Set([this._focused]);
-    } else {
-      return new Set();
-    }
-  }
+    _rawData;
+    _getChildren;
+    _data;
+    _selected;
+    _focused;
+    _getKey;
+    _isItemSelectable;
+    constructor({ data = [], selected = new Set(), focused = null, getKey = item => item.id, getChildren = () => [], isItemSelectable = () => true } = {}) {
+        this._rawData = data;
+        this._getChildren = getChildren;
+        this._data = this._buildData(data);
+        this._selected = selected;
+        this._focused = focused;
+        this._getKey = getKey;
+        this._isItemSelectable = isItemSelectable;
+    }
+    _buildData(data) {
+        return new Set(data);
+    }
+    _buildSelected(data, selected) {
+        return new Set(selected);
+    }
+    cloneWith({ data, selected, focused }) {
+        const newData = data || this._rawData;
+        let newSelected;
+        if (data && !selected) {
+            newSelected = new Set([...this._buildData(newData)].
+                filter(item => [...this._selected].some(it => this._getKey(item) === this._getKey(it))));
+            newSelected = this._buildSelected(this._buildData(newData), newSelected);
+        }
+        else if (selected) {
+            newSelected = selected;
+        }
+        else {
+            newSelected = this._selected;
+        }
+        newSelected = new Set([...newSelected].filter(item => this._isItemSelectable(item)));
+        const cloneFocus = () => [...this._buildData(data)].filter(item => this._focused && this._getKey(item) === this._getKey(this._focused))[0];
+        const newFocused = focused === undefined ? this._focused : focused;
+        return new this.constructor({
+            data: newData,
+            selected: newSelected,
+            focused: (data && !focused) ? cloneFocus() : newFocused,
+            getKey: this._getKey,
+            getChildren: this._getChildren,
+            isItemSelectable: this._isItemSelectable
+        });
+    }
+    focus(value) {
+        return this.cloneWith({ focused: value });
+    }
+    moveUp() {
+        const focused = this._focused;
+        const data = [...this._data];
+        if (!focused) {
+            return this.cloneWith({ focused: data[data.length - 1] });
+        }
+        const nextItem = data[data.indexOf(focused) - 1];
+        if (nextItem) {
+            return this.cloneWith({ focused: nextItem });
+        }
+        return undefined;
+    }
+    moveDown() {
+        const focused = this._focused;
+        const data = [...this._data];
+        if (!focused) {
+            return this.cloneWith({ focused: data[0] });
+        }
+        const nextItem = data[data.indexOf(focused) + 1];
+        if (nextItem) {
+            return this.cloneWith({ focused: nextItem });
+        }
+        return undefined;
+    }
+    moveStart() {
+        const data = [...this._data];
+        if (data.length) {
+            return this.cloneWith({ focused: data[0] });
+        }
+        return undefined;
+    }
+    moveEnd() {
+        const data = [...this._data];
+        if (data.length) {
+            return this.cloneWith({ focused: data.pop() });
+        }
+        return undefined;
+    }
+    select(value = this._focused) {
+        if (!value || !this._isItemSelectable(value)) {
+            return this;
+        }
+        const selected = new Set(this._selected);
+        selected.add(value);
+        return this.cloneWith({ selected });
+    }
+    deselect(value = this._focused) {
+        if (!value || !this._isItemSelectable(value)) {
+            return this;
+        }
+        const selected = new Set(this._selected);
+        selected.delete(value);
+        return this.cloneWith({ selected });
+    }
+    toggleSelection(value = this._focused) {
+        if (this.isSelected(value)) {
+            return this.deselect(value);
+        }
+        else {
+            return this.select(value);
+        }
+    }
+    selectAll() {
+        return this.cloneWith({ selected: [...this._data] });
+    }
+    resetFocus() {
+        return this.cloneWith({ focused: null });
+    }
+    resetSelection() {
+        return this.cloneWith({ selected: new Set() });
+    }
+    reset() {
+        return this.resetFocus().resetSelection();
+    }
+    isFocused(value) {
+        return this._focused === value;
+    }
+    isSelected(value) {
+        return value != null && this._selected.has(value);
+    }
+    getFocused() {
+        return this._focused;
+    }
+    getSelected() {
+        return new Set(this._selected);
+    }
+    getActive() {
+        if (this._selected.size) {
+            return new Set(this._selected);
+        }
+        else if (this._focused) {
+            return new Set([this._focused]);
+        }
+        else {
+            return new Set();
+        }
+    }
 }

package/components/table/smart-table.d.ts

@@ -0,0 +1,60 @@
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import { TableAttrs } from './table';
+import Selection, { SelectionItem } from './selection';
+export interface SmartTableProps<T extends SelectionItem> extends Omit<TableAttrs<T>, 'selection' | 'onSelect'> {
+    onSelectionChange: (selection: Selection<T>) => void;
+}
+declare class SmartTable<T extends SelectionItem> extends PureComponent<SmartTableProps<T>> {
+    static propTypes: {
+        className?: React.Validator<string | null | undefined> | undefined;
+        onFocus?: React.Validator<(() => void) | null | undefined> | undefined;
+        onBlur?: React.Validator<(() => void) | null | undefined> | undefined;
+        caption?: React.Validator<string | null | undefined> | undefined;
+        data?: React.Validator<readonly SelectionItem[]> | undefined;
+        loading?: React.Validator<boolean | null | undefined> | undefined;
+        draggable?: React.Validator<boolean | null | undefined> | undefined;
+        columns?: React.Validator<readonly import("./header-cell").Column<SelectionItem>[]> | undefined;
+        focused?: React.Validator<boolean | null | undefined> | undefined;
+        isItemSelectable: PropTypes.Requireable<(...args: any[]) => any> | React.Validator<((item: SelectionItem) => boolean) | null | undefined>;
+        innerRef?: React.Validator<React.Ref<HTMLTableRowElement> | undefined> | undefined;
+        autofocus?: React.Validator<boolean | null | undefined> | undefined;
+        disabledHover?: React.Validator<boolean> | undefined;
+        remoteSelection?: React.Validator<boolean | null | undefined> | undefined;
+        onSort?: React.Validator<((params: import("./header-cell").SortParams) => void) | null | undefined> | undefined;
+        sortKey?: React.Validator<string | null | undefined> | undefined;
+        sortOrder?: React.Validator<boolean | null | undefined> | undefined;
+        alwaysShowDragHandle?: React.Validator<boolean | null | undefined> | undefined;
+        onReorder?: React.Validator<((params: import("./table").ReorderParams<SelectionItem>) => void) | null | undefined> | undefined;
+        getItemKey?: React.Validator<((item: SelectionItem) => string | number) | null | undefined> | undefined;
+        stickyHeader?: React.Validator<boolean | null | undefined> | undefined;
+        getItemLevel?: React.Validator<((item: SelectionItem) => number) | null | undefined> | undefined;
+        getItemClassName?: React.Validator<((item: SelectionItem) => string | null | undefined) | null | undefined> | undefined;
+        getItemDataTest?: React.Validator<((item: SelectionItem) => string | null | undefined) | null | undefined> | undefined;
+        isItemCollapsible?: React.Validator<((item: SelectionItem) => boolean) | null | undefined> | undefined;
+        isParentCollapsible?: React.Validator<((item: SelectionItem) => boolean) | null | undefined> | undefined;
+        isItemCollapsed?: React.Validator<((item: SelectionItem) => boolean) | null | undefined> | undefined;
+        onItemCollapse?: React.Validator<((item: SelectionItem) => void) | null | undefined> | undefined;
+        onItemExpand?: React.Validator<((item: SelectionItem) => void) | null | undefined> | undefined;
+        onItemDoubleClick?: React.Validator<((item: SelectionItem) => void) | null | undefined> | undefined;
+        onItemClick?: React.Validator<((item: SelectionItem, e: React.MouseEvent<HTMLTableRowElement, MouseEvent>) => void) | null | undefined> | undefined;
+        isDisabledSelectionVisible?: React.Validator<((item: SelectionItem) => boolean) | null | undefined> | undefined;
+        getCheckboxTooltip?: React.Validator<((item: SelectionItem) => string | undefined) | null | undefined> | undefined;
+        loaderClassName?: React.Validator<string | null | undefined> | undefined;
+        stickyHeaderOffset?: React.Validator<string | null | undefined> | undefined;
+        renderEmpty?: React.Validator<(() => React.ReactNode) | null | undefined> | undefined;
+        selectable?: React.Validator<boolean | null | undefined> | undefined;
+        shortcuts?: React.Validator<import("../shortcuts/core").ShortcutsMap | null | undefined> | undefined;
+        onSelectionChange: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    static defaultProps: {
+        onSelectionChange: () => void;
+    };
+    state: {
+        selection: Selection<T>;
+    };
+    UNSAFE_componentWillReceiveProps(nextProps: SmartTableProps<T>): void;
+    onSelect: (selection: Selection<T>) => void;
+    render(): JSX.Element;
+}
+export default SmartTable;

package/components/table/smart-table.jsx

@@ -0,0 +1,36 @@
+import React, { PureComponent } from 'react';
+import PropTypes from 'prop-types';
+import Table from './table';
+import Selection from './selection';
+const { selection: __selection__, onSelect: __onSelect__, ...restPropTypes } = Table.propTypes ?? {};
+class SmartTable extends PureComponent {
+    static propTypes = {
+        onSelectionChange: PropTypes.func,
+        isItemSelectable: PropTypes.func,
+        ...restPropTypes
+    };
+    static defaultProps = {
+        onSelectionChange: () => { }
+    };
+    state = {
+        selection: new Selection({
+            data: this.props.data,
+            isItemSelectable: this.props.isItemSelectable
+        })
+    };
+    UNSAFE_componentWillReceiveProps(nextProps) {
+        const { data, isItemSelectable } = nextProps;
+        if (this.props.data !== data || this.props.isItemSelectable !== isItemSelectable) {
+            const selection = new Selection({ data, isItemSelectable });
+            this.setState({ selection });
+        }
+    }
+    onSelect = (selection) => {
+        this.setState({ selection });
+        this.props.onSelectionChange(selection);
+    };
+    render() {
+        return (<Table {...this.props} selection={this.state.selection} onSelect={this.onSelect}/>);
+    }
+}
+export default SmartTable;

package/components/table/table.d.ts

@@ -0,0 +1,160 @@
+/**
+ * @name Table
+ */
+import React, { Component, PureComponent, ReactNode, SyntheticEvent } from 'react';
+import { OnChangeMeta } from 'react-movable/lib/types';
+import { FocusSensorAddProps, FocusSensorProps } from '../global/focus-sensor-hoc';
+import { SelectionItem } from './selection';
+import { SelectionShortcutsAddProps, SelectionShortcutsProps } from './selection-shortcuts-hoc';
+import { DisableHoverAddProps, DisableHoverProps } from './disable-hover-hoc';
+import { Column, SortParams } from './header-cell';
+export interface ReorderParams<T> {
+    data: T[];
+    oldIndex: number;
+    newIndex: number;
+}
+export interface TableProps<T extends SelectionItem> extends FocusSensorAddProps<HTMLTableRowElement>, SelectionShortcutsAddProps<T>, DisableHoverAddProps {
+    data: readonly T[];
+    columns: readonly Column<T>[];
+    isItemSelectable: (item: T) => boolean;
+    loading: boolean;
+    onSort: (params: SortParams) => void;
+    onReorder: (params: ReorderParams<T>) => void;
+    getItemKey: (item: T) => string | number;
+    sortKey: string;
+    sortOrder: boolean;
+    draggable: boolean;
+    alwaysShowDragHandle: boolean;
+    stickyHeader: boolean;
+    getItemLevel: (item: T) => number;
+    getItemClassName: (item: T) => string | null | undefined;
+    getItemDataTest: (item: T) => string | null | undefined;
+    isItemCollapsible: (item: T) => boolean;
+    isParentCollapsible: (item: T) => boolean;
+    isItemCollapsed: (item: T) => boolean;
+    onItemCollapse: (item: T) => void;
+    onItemExpand: (item: T) => void;
+    onItemDoubleClick: (item: T) => void;
+    onItemClick: (item: T, e: React.MouseEvent<HTMLTableRowElement>) => void;
+    remoteSelection: boolean;
+    isDisabledSelectionVisible: (item: T) => boolean;
+    getCheckboxTooltip: (item: T) => string | undefined;
+    className?: string | null | undefined;
+    loaderClassName?: string | undefined;
+    caption?: string | null | undefined;
+    stickyHeaderOffset?: string | undefined;
+    renderEmpty?: (() => ReactNode) | null | undefined;
+}
+/**
+ * Interactive table with selection and keyboard navigation support.
+ */
+export declare class Table<T extends SelectionItem> extends PureComponent<TableProps<T>> {
+    static defaultProps: {
+        isItemSelectable: () => boolean;
+        loading: boolean;
+        onSort: () => void;
+        onReorder: () => void;
+        getItemKey: (item: SelectionItem) => string | number;
+        sortKey: string;
+        sortOrder: boolean;
+        draggable: boolean;
+        alwaysShowDragHandle: boolean;
+        stickyHeader: boolean;
+        getItemLevel: () => number;
+        getItemClassName: () => null;
+        getItemDataTest: () => null;
+        isItemCollapsible: () => boolean;
+        isParentCollapsible: () => boolean;
+        isItemCollapsed: () => boolean;
+        onItemCollapse: () => void;
+        onItemExpand: () => void;
+        onItemDoubleClick: () => void;
+        onItemClick: () => void;
+        remoteSelection: boolean;
+        isDisabledSelectionVisible: () => boolean;
+        getCheckboxTooltip: () => undefined;
+    };
+    state: {
+        shortcutsScope: string;
+        userSelectNone: boolean;
+    };
+    componentDidMount(): void;
+    componentDidUpdate({ data, selection, onSelect, selectable, remoteSelection }: TableProps<T>): void;
+    componentWillUnmount(): void;
+    onMouseDown: (e: React.MouseEvent) => void;
+    onMouseUp: () => void;
+    onRowFocus: (row: T) => void;
+    onRowSelect: (row: T, selected: boolean) => void;
+    onSortEnd: ({ oldIndex, newIndex }: OnChangeMeta) => void;
+    onCheckboxChange: (e: SyntheticEvent<HTMLInputElement>) => void;
+    restoreFocusWithoutScroll: () => void;
+    render(): JSX.Element;
+}
+export declare type TableAttrs<T extends SelectionItem> = DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>;
+export default class TableContainer<T extends SelectionItem> extends Component<TableAttrs<T>> {
+    static propTypes: React.WeakValidationMap<SelectionShortcutsProps<SelectionItem, FocusSensorProps<TableProps<SelectionItem>, HTMLTableRowElement, typeof Table>>> | undefined;
+    Table: {
+        new (props: DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>> | Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>): {
+            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<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+            forceUpdate(callback?: (() => void) | undefined): void;
+            readonly props: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>> & Readonly<{
+                children?: React.ReactNode;
+            }>;
+            refs: {
+                [key: string]: React.ReactInstance;
+            };
+            shouldComponentUpdate?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextState: Readonly<{}>, nextContext: any): boolean;
+            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+            getSnapshotBeforeUpdate?(prevProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, prevState: Readonly<{}>): any;
+            componentDidUpdate?(prevProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, prevState: Readonly<{}>, snapshot?: any): void;
+            componentWillMount?(): void;
+            UNSAFE_componentWillMount?(): void;
+            componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextContext: any): void;
+            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextContext: any): void;
+            componentWillUpdate?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextState: Readonly<{}>, nextContext: any): void;
+            UNSAFE_componentWillUpdate?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextState: Readonly<{}>, nextContext: any): void;
+        };
+        new (props: DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>, 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<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+            forceUpdate(callback?: (() => void) | undefined): void;
+            readonly props: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>> & Readonly<{
+                children?: React.ReactNode;
+            }>;
+            refs: {
+                [key: string]: React.ReactInstance;
+            };
+            shouldComponentUpdate?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextState: Readonly<{}>, nextContext: any): boolean;
+            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+            getSnapshotBeforeUpdate?(prevProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, prevState: Readonly<{}>): any;
+            componentDidUpdate?(prevProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, prevState: Readonly<{}>, snapshot?: any): void;
+            componentWillMount?(): void;
+            UNSAFE_componentWillMount?(): void;
+            componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextContext: any): void;
+            UNSAFE_componentWillReceiveProps?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextContext: any): void;
+            componentWillUpdate?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextState: Readonly<{}>, nextContext: any): void;
+            UNSAFE_componentWillUpdate?(nextProps: Readonly<DisableHoverProps<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>>>, nextState: Readonly<{}>, nextContext: any): void;
+        };
+        propTypes: React.WeakValidationMap<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>> | undefined;
+        defaultProps: Partial<SelectionShortcutsProps<T, FocusSensorProps<TableProps<T>, HTMLTableRowElement, typeof Table>>> | undefined;
+        contextType?: React.Context<any> | undefined;
+    };
+    render(): JSX.Element;
+}