@jetbrains/ring-ui 5.1.21 → 5.1.23

package/components/table/row.js

@@ -1,154 +0,0 @@
-import React, { PureComponent } from 'react';
-import PropTypes from 'prop-types';
-import classNames from 'classnames';
-import chevronRightIcon from '@jetbrains/icons/chevron-right';
-import chevronDownIcon from '@jetbrains/icons/chevron-down';
-import dragIcon from '@jetbrains/icons/drag';
-import Checkbox from '../checkbox/checkbox';
-import Button from '../button/button';
-import Tooltip from '../tooltip/tooltip';
-import dataTests from '../global/data-tests';
-import getUID from '../global/get-uid';
-import composeRefs from '../global/composeRefs';
-import Cell from './cell';
-import style from './table.css';
-const DragHandle = ({ alwaysShowDragHandle, dragHandleTitle = 'Drag to reorder' }) => {
-    const classes = classNames(style.dragHandle, {
-        [style.visibleDragHandle]: alwaysShowDragHandle
-    });
-    return (<Button data-movable-handle title={dragHandleTitle} className={classes} icon={dragIcon}/>);
-};
-DragHandle.propTypes = {
-    alwaysShowDragHandle: PropTypes.bool,
-    dragHandleTitle: PropTypes.string
-};
-export default class Row extends PureComponent {
-    static defaultProps = {
-        selectable: true,
-        showFocus: false,
-        draggable: false,
-        alwaysShowDragHandle: false,
-        selected: false,
-        onHover: () => { },
-        onSelect: () => { },
-        onDoubleClick: () => { },
-        onClick: () => { },
-        level: 0,
-        collapsible: false,
-        parentCollapsible: false,
-        collapsed: false,
-        onCollapse: () => { },
-        onExpand: () => { }
-    };
-    id = getUID('table-row-');
-    onMouseEnter = (e) => {
-        const { item, onHover } = this.props;
-        onHover(item, e);
-    };
-    onClick = (e) => {
-        const { item } = this.props;
-        this.props.onClick(item, e);
-        if (e.shiftKey) {
-            this.toggleSelection();
-        }
-    };
-    onCheckboxFocus = () => {
-        this.props.onFocusRestore();
-    };
-    onCheckboxChange = () => {
-        this.toggleSelection();
-    };
-    toggleSelection() {
-        const { selectable, selected, onSelect, item } = this.props;
-        if (selectable) {
-            onSelect(item, !selected);
-        }
-    }
-    onDoubleClick = () => {
-        const { item } = this.props;
-        this.props.onDoubleClick(item);
-    };
-    row;
-    rowRef = (el) => {
-        this.row = el;
-    };
-    render() {
-        const { item, columns, selectable, selected, showFocus, draggable, alwaysShowDragHandle, dragHandleTitle, level, collapsible, parentCollapsible, collapsed, onCollapse, onExpand, showDisabledSelection, onSelect, checkboxTooltip, innerRef, focused, autofocus, onFocusReset, onFocusRestore, onHover, className, metaColumnClassName, 'data-test': dataTest, ...restProps } = this.props;
-        const classes = classNames(className, {
-            [style.row]: true,
-            [style.rowFocused]: showFocus,
-            [style.rowSelected]: selected
-        });
-        const testAttrs = {
-            'data-test-focused': showFocus || undefined,
-            'data-test-selected': selected || undefined
-        };
-        const metaColumnClasses = classNames(metaColumnClassName, style.metaColumn);
-        const SUBITEM_OFFSET = 30;
-        const COLLAPSIBLE_PARENT_OFFSET = 20;
-        const gap = level * SUBITEM_OFFSET + (parentCollapsible ? COLLAPSIBLE_PARENT_OFFSET : 0);
-        const metaColumnStyle = {
-            paddingLeft: `${gap}px`
-        };
-        const metaColumn = (<div className={metaColumnClasses} style={metaColumnStyle}>
-        {draggable && (<DragHandle alwaysShowDragHandle={alwaysShowDragHandle} dragHandleTitle={dragHandleTitle}/>)}
-
-        {selectable &&
-                (<Tooltip title={checkboxTooltip}>
-              <Checkbox aria-labelledby={this.id} className={showFocus ? 'ring-checkbox_focus' : ''} checked={selected} onFocus={this.onCheckboxFocus} onChange={this.onCheckboxChange} tabIndex={-1}/>
-            </Tooltip>)}
-
-        {!selectable && showDisabledSelection &&
-                (<Tooltip title={checkboxTooltip}>
-              <Checkbox aria-labelledby={this.id} checked={selected} disabled/>
-            </Tooltip>)}
-
-        {collapsible && collapsed &&
-                (<Button className={style.rowCollapseExpandButton} icon={chevronRightIcon} onClick={() => onExpand(item)}/>)}
-
-        {collapsible && !collapsed &&
-                (<Button className={style.rowCollapseExpandButton} icon={chevronDownIcon} onClick={() => onCollapse(item)}/>)}
-      </div>);
-        const cells = columns.map((column, index) => {
-            const getValue = column.getValue || (() => item[column.id]);
-            const getDataTest = column.getDataTest || (() => column.id);
-            const value = getValue(item, column);
-            const cellClasses = classNames({ [style.cellRight]: column.rightAlign }, column.className);
-            const showMetaColumn = draggable || selectable || collapsible || showDisabledSelection || !!level;
-            return (<Cell key={column.id} className={cellClasses} data-test={getDataTest(item, column)}>
-          {index === 0 && (showMetaColumn) && metaColumn}
-          {value}
-        </Cell>);
-        });
-        return (<tr id={this.id} ref={composeRefs(this.rowRef, innerRef)} className={classes} tabIndex={0} data-test={dataTests('ring-table-row', dataTest)} {...testAttrs} {...restProps} onMouseMove={this.onMouseEnter} onClick={this.onClick} onDoubleClick={this.onDoubleClick}>{cells}</tr>);
-    }
-}
-Row.propTypes = {
-    className: PropTypes.string,
-    metaColumnClassName: PropTypes.string,
-    item: PropTypes.object.isRequired,
-    columns: PropTypes.array.isRequired,
-    selectable: PropTypes.bool,
-    showFocus: PropTypes.bool,
-    draggable: PropTypes.bool,
-    alwaysShowDragHandle: PropTypes.bool,
-    selected: PropTypes.bool,
-    onHover: PropTypes.func,
-    onSelect: PropTypes.func,
-    onDoubleClick: PropTypes.func,
-    onClick: PropTypes.func,
-    onFocusRestore: PropTypes.func,
-    level: PropTypes.number,
-    collapsible: PropTypes.bool,
-    parentCollapsible: PropTypes.bool,
-    collapsed: PropTypes.bool,
-    onCollapse: PropTypes.func,
-    onExpand: PropTypes.func,
-    showDisabledSelection: PropTypes.bool,
-    checkboxTooltip: PropTypes.string,
-    innerRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object]),
-    focused: PropTypes.bool,
-    autofocus: PropTypes.bool,
-    onFocusReset: PropTypes.func,
-    'data-test': PropTypes.string
-};

package/components/table/selection-adapter.d.ts

@@ -1,5 +0,0 @@
-import Selection, { SelectionItem } from './selection';
-export default function selectionAdapter(getSelection: () => Selection<SelectionItem>): {
-    readonly size: number;
-    readonly items: SelectionItem[];
-};

package/components/table/selection-adapter.js

@@ -1,10 +0,0 @@
-export default function selectionAdapter(getSelection) {
-    return {
-        get size() {
-            return getSelection().getActive().size;
-        },
-        get items() {
-            return [...getSelection().getActive()];
-        }
-    };
-}

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

@@ -1,17 +0,0 @@
-import { ComponentType } from 'react';
-import { ShortcutsMap } from '../shortcuts/core';
-import Selection, { SelectionItem } from './selection';
-export interface SelectionShortcutsOuterProps<T extends SelectionItem> {
-    selection: Selection<T>;
-    selectable?: boolean | undefined;
-    onSelect?: ((selection: Selection<T>) => void) | undefined;
-    shortcuts?: ShortcutsMap | undefined;
-}
-export interface SelectionShortcutsAddProps<T extends SelectionItem> {
-    selection: Selection<T>;
-    selectable: boolean;
-    onSelect: (selection: Selection<T>) => void;
-    shortcutsMap: ShortcutsMap;
-}
-export type SelectionShortcutsProps<T extends SelectionItem, P> = Omit<P, keyof SelectionShortcutsAddProps<T>> & SelectionShortcutsOuterProps<T>;
-export default function selectionShortcutsHOC<T extends SelectionItem, P extends SelectionShortcutsAddProps<T>>(ComposedComponent: ComponentType<P>): ComponentType<SelectionShortcutsProps<T, P>>;

package/components/table/selection-shortcuts-hoc.js

@@ -1,146 +0,0 @@
-import React, { PureComponent } from 'react';
-import PropTypes from 'prop-types';
-import Selection from './selection';
-function extractPropTypes({ propTypes }) {
-    if (propTypes == null) {
-        return propTypes;
-    }
-    const { selection, selectable, onSelect, shortcutsMap, ...restPropTypes } = propTypes;
-    return restPropTypes;
-}
-export default function selectionShortcutsHOC(ComposedComponent) {
-    class SelectionShortcuts extends PureComponent {
-        onUpPress = () => {
-            const { selection, onSelect } = this.props;
-            const newSelection = selection.moveUp();
-            if (newSelection) {
-                onSelect?.(newSelection);
-            }
-            return false;
-        };
-        onDownPress = () => {
-            const { selection, onSelect } = this.props;
-            const newSelection = selection.moveDown();
-            if (newSelection) {
-                onSelect?.(newSelection);
-            }
-            return false;
-        };
-        shiftSelectionMode;
-        onShiftKeyDown = () => {
-            const { selection } = this.props;
-            if (selection.isSelected(selection.getFocused())) {
-                this.shiftSelectionMode = 'deletion';
-            }
-            else {
-                this.shiftSelectionMode = 'addition';
-            }
-        };
-        shiftSelect = (selection) => {
-            if (this.shiftSelectionMode === 'addition') {
-                return selection.select();
-            }
-            else {
-                return selection.deselect();
-            }
-        };
-        onShiftUpPress = (e) => {
-            e.preventDefault();
-            const { selectable, selection, onSelect } = this.props;
-            if (!selectable) {
-                return;
-            }
-            const newSelection = this.shiftSelect(selection);
-            const newMovedSelection = newSelection.moveUp();
-            if (newMovedSelection) {
-                onSelect?.(newMovedSelection);
-            }
-            else {
-                onSelect?.(newSelection);
-            }
-        };
-        onShiftDownPress = (e) => {
-            e.preventDefault();
-            const { selectable, selection, onSelect } = this.props;
-            if (!selectable) {
-                return;
-            }
-            const newSelection = this.shiftSelect(selection);
-            const newMovedSelection = newSelection.moveDown();
-            if (newMovedSelection) {
-                onSelect?.(newMovedSelection);
-            }
-            else {
-                onSelect?.(newSelection);
-            }
-        };
-        onHomePress = () => {
-            const { selection, onSelect } = this.props;
-            const newSelection = selection.moveStart();
-            if (newSelection) {
-                onSelect?.(newSelection);
-            }
-            return false;
-        };
-        onEndPress = () => {
-            const { selection, onSelect } = this.props;
-            const newSelection = selection.moveEnd();
-            if (newSelection) {
-                onSelect?.(newSelection);
-            }
-            return false;
-        };
-        onSpacePress = () => {
-            const { selectable, selection, onSelect } = this.props;
-            if (!selectable) {
-                return true;
-            }
-            onSelect?.(selection.toggleSelection());
-            return false;
-        };
-        onEscPress = () => {
-            const { selection, onSelect } = this.props;
-            onSelect?.(selection.reset());
-            //this.restoreFocusWithoutScroll();
-        };
-        onCmdAPress = () => {
-            const { selectable, selection, onSelect } = this.props;
-            if (!selectable) {
-                return true;
-            }
-            onSelect?.(selection.selectAll());
-            return false;
-        };
-        shortcutsMap = {
-            up: this.onUpPress,
-            down: this.onDownPress,
-            shift: this.onShiftKeyDown,
-            'shift+up': this.onShiftUpPress,
-            'shift+down': this.onShiftDownPress,
-            home: this.onHomePress,
-            end: this.onEndPress,
-            space: this.onSpacePress,
-            esc: this.onEscPress,
-            'command+a': this.onCmdAPress,
-            'ctrl+a': this.onCmdAPress
-        };
-        render() {
-            const { selection, selectable, onSelect, shortcuts, ...restProps } = this.props;
-            return (<ComposedComponent {...restProps} selection={selection} selectable={selectable} onSelect={onSelect} shortcutsMap={{ ...this.shortcutsMap, ...this.props.shortcuts }}/>);
-        }
-    }
-    SelectionShortcuts.propTypes = {
-        ...extractPropTypes(ComposedComponent),
-        selection: PropTypes.instanceOf(Selection).isRequired,
-        selectable: PropTypes.bool,
-        onSelect: PropTypes.func,
-        shortcuts: PropTypes.object
-    };
-    SelectionShortcuts.defaultProps = {
-        ...ComposedComponent.defaultProps,
-        selectable: true,
-        onSelect: () => { },
-        shortcuts: {}
-    };
-    return SelectionShortcuts;
-}

package/components/table/selection.d.ts

@@ -1,47 +0,0 @@
-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,150 +0,0 @@
-export default class Selection {
-    _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

@@ -1,64 +0,0 @@
-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;
-    selection?: Selection<T>;
-}
-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;
-        scrollOnTableFocus?: 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;
-        dragHandleTitle?: React.Validator<string | 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;
-        getMetaColumnClassName?: 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(): React.JSX.Element;
-}
-export default SmartTable;

package/components/table/smart-table.js

@@ -1,40 +0,0 @@
-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, selection } = nextProps;
-        if (this.props.remoteSelection && this.props.selection !== selection) {
-            this.setState({ selection });
-        }
-        else if (this.props.data !== data || this.props.isItemSelectable !== isItemSelectable) {
-            this.setState({
-                selection: new Selection({ data, isItemSelectable })
-            });
-        }
-    }
-    onSelect = (selection) => {
-        this.setState({ selection });
-        this.props.onSelectionChange(selection);
-    };
-    render() {
-        return (<Table {...this.props} selection={this.state.selection} onSelect={this.onSelect}/>);
-    }
-}
-export default SmartTable;