react-ui-basics 0.0.148 → 0.0.151

package/Table.d.ts

@@ -0,0 +1,76 @@
+import { Component, ReactElement } from 'react';
+import './Table.css';
+export declare const SORT_ASC: string;
+export declare const SORT_DESC: string;
+declare type SortOrder = typeof SORT_ASC | typeof SORT_DESC;
+declare type Comparator = <T>(a: T, b: T) => number;
+declare const editorSelect = "Select";
+declare const editorSwitch = "Switch";
+export interface RowProps {
+    item: any;
+    disabled?: <T>(e: T) => boolean;
+    editing: any;
+    onClick?: (e: MouseEvent) => void;
+    className?: string | (<T>(e: T) => string);
+    columns: TableColumn[];
+    editingContext: any;
+}
+export declare type Formatter<T, V> = ((value?: V, item?: T, format?: string) => ReactElement) | ((value: V, item: T) => ReactElement) | ((value: V) => ReactElement);
+export interface TableColumn {
+    field?: string;
+    className?: string;
+    comparator?: Comparator;
+    header?: string | ReactElement;
+    sortable?: boolean;
+    displayEditor?: boolean;
+    formatter?: Formatter<any, any>;
+    editable?: boolean | any;
+    editor?: typeof editorSelect | typeof editorSwitch | any;
+    preEditor?: any;
+}
+export interface TableProps {
+    columns: TableColumn[];
+    data: any[];
+    className?: string;
+    sortOrder?: SortOrder;
+    sortBy?: string;
+    onSortChange?: (sortBy: string, sortOrder: SortOrder) => void;
+    onRowClick?: (e: MouseEvent) => void;
+    disabled?: <T>(e: T) => boolean;
+    toKey?: <T>(e: T) => number | string;
+    onChange?: <T>(e: T, cancel: () => void) => void;
+    rowClassName?: string | (<T>(e: T) => string);
+}
+export interface TableState {
+    sortOrder?: SortOrder;
+    sortBy?: string;
+    comparator?: Comparator;
+    data?: any[];
+    editing?: any;
+}
+declare class Table extends Component<TableProps, TableState> {
+    headers: () => any;
+    updateHeadersInterval: number;
+    constructor(props: any);
+    componentDidMount(): void;
+    setData: (data: any) => void;
+    componentDidUpdate(prevProps: any, prevState: any, snapshot: any): void;
+    render(): JSX.Element;
+    componentWillUnmount(): void;
+    updateHeaders: () => void;
+    cancelEditing: () => void;
+    setEditing: (item: any, columnIndex: any, field: any) => void;
+    prepareEditing: (item: any, field: any, columnIndex: any) => {
+        id: any;
+        value: any;
+        columnIndex: any;
+        item: any;
+        field: any;
+    };
+    handleInputChange: (event: any) => void;
+    extractValue: (event: any) => any;
+    selectNewValue: (value: any) => void;
+    onFinishEditing: () => void;
+    sort: (e: any, sortBy: any, comparator: any) => void;
+}
+export default Table;

package/Table.js

@@ -1,337 +1,154 @@
-import { inherits as _inherits, createSuper as _createSuper, classCallCheck as _classCallCheck, toConsumableArray as _toConsumableArray, objectSpread2 as _objectSpread2, defineProperty as _defineProperty, createClass as _createClass } from './_virtual/_rollupPluginBabelHelpers.js';
+import { jsx as jsxRuntime_2, jsxs as jsxRuntime_1 } from 'react/jsx-runtime';
+import {extends as __extends} from "./_virtual/_rollupPluginBabelHelpers";
+import {className as __className} from "./ReactConstants";
+import {children as __children} from "./ReactConstants";
 import React, { Component } from 'react';
-import ReactCreateElement from './ReactCreateElement.js';
-import PropTypes from 'prop-types';
 import TextField from './TextField.js';
 import AutocompleteSelect, { MODE_MULTIPLE_MINI, MODE_DEFAULT } from './AutocompleteSelect.js';
 import Switch from './Switch.js';
-import { Comparators, orNoop, isString, preventDefault, classNames, isFunction, NOOP, stopPropagation } from './Tools.js';
+import { classNames, isFunction, NOOP, preventDefault, stopPropagation, createRef, Comparators, orNoop, isString, setInterval } from './Tools.js';
 import MaterialIcon from './MaterialIcon.js';
 
-var SORT_ASC = Comparators.SORT_ASC;
-var SORT_DESC = Comparators.SORT_DESC;
-var getId = function getId(item) {
-  return item.id;
-};
-var Table = function (_Component) {
-  _inherits(Table, _Component);
-  var _super = _createSuper(Table);
-  function Table(props) {
-    var _this;
-    _classCallCheck(this, Table);
-    _this = _super.call(this, props);
-    _this.setData = function (data) {
-      var _this$state = _this.state,
-          sortBy = _this$state.sortBy,
-          sortOrder = _this$state.sortOrder,
-          comparator = _this$state.comparator;
-      data = _toConsumableArray(data);
-      if (sortBy) {
-        var c = comparator;
-        if (c && sortOrder === SORT_DESC) c = Comparators.inverse(c);
-        data.sort(c || Comparators.of(sortBy, sortOrder, data));
-      }
-      _this.setState({
-        data: data
-      }, function () {
-        orNoop(_this.props.onSortChange)(sortBy, sortOrder);
-      });
-    };
-    _this.updateHeaders = function () {
-      var headers = _this.headers;
-      var hidden = headers.querySelectorAll('.hidden');
-      var fixed = headers.querySelectorAll('.fixed');
-      for (var i = 0; i < hidden.length; i++) {
-        fixed[i].style.width = hidden[i].offsetWidth + 'px';
-      }
-    };
-    _this.cancelEditing = function () {
-      return _this.setState({
-        editing: false
-      });
-    };
-    _this.setEditing = function (item, columnIndex, field) {
-      return _this.setState({
-        editing: _this.prepareEditing(item, field, columnIndex)
-      });
-    };
-    _this.prepareEditing = function (item, field, columnIndex) {
-      return {
-        id: item.id,
-        value: item[field],
-        columnIndex: columnIndex,
-        item: item,
-        field: field
-      };
-    };
-    _this.handleInputChange = function (event) {
-      var value = _this.extractValue(event);
-      _this.setState({
-        editing: _objectSpread2(_objectSpread2({}, _this.state.editing), {}, {
-          value: value
-        })
-      });
-    };
-    _this.extractValue = function (event) {
-      var target = event.target;
-      return target.type === 'checkbox' ? target.checked : target.value;
-    };
-    _this.selectNewValue = function (value) {
-      _this.setState({
-        editing: _objectSpread2(_objectSpread2({}, _this.state.editing), {}, {
-          value: value
-        })
-      }, _this.onFinishEditing);
-    };
-    _this.onFinishEditing = function (e) {
-      var editing = _this.state.editing;
-      if (editing.value === null) return;
-      var value = editing.value;
-      if (isString(value)) value = value.trim();
-      if (value === editing.item[editing.field]) return _this.cancelEditing();
-      var updated = _objectSpread2(_objectSpread2({}, editing.item), {}, _defineProperty({}, editing.field, value));
-      _this.props.onChange(updated, _this.cancelEditing);
-    };
-    _this.sort = function (e, sortBy, comparator) {
-      preventDefault(e);
-      _this.setState({
-        sortOrder: _this.state.sortBy === sortBy && _this.state.sortOrder === SORT_ASC ? SORT_DESC : SORT_ASC,
-        comparator: comparator,
-        sortBy: sortBy
-      }, function () {
-        return _this.setData(_this.state.data);
-      });
-    };
-    _this.state = {};
-    return _this;
-  }
-  _createClass(Table, [{
-    key: "componentDidMount",
-    value: function componentDidMount() {
-      var _columns$find,
-          _this2 = this;
-      var _this$props = this.props,
-          sortBy = _this$props.sortBy,
-          _this$props$sortOrder = _this$props.sortOrder,
-          sortOrder = _this$props$sortOrder === void 0 ? SORT_ASC : _this$props$sortOrder,
-          columns = _this$props.columns;
-      this.setState({
-        sortBy: sortBy,
-        sortOrder: sortOrder,
-        comparator: (_columns$find = columns.find(function (it) {
-          return it.field === sortBy;
-        })) == null ? void 0 : _columns$find.comparator
-      }, function () {
-        return _this2.setData(_this2.props.data);
-      });
-      this.updateHeaders();
-      this.updateHeadersInterval = setInterval(this.updateHeaders, 1000);
+const SORT_ASC = Comparators.SORT_ASC;
+const SORT_DESC = Comparators.SORT_DESC;
+const getId = item => item.id;
+const editorSelect = 'Select';
+const editorSwitch = 'Switch';
+class Table extends Component {
+    constructor(props) {
+        super(props);
+        this.headers = createRef();
+        this.updateHeadersInterval = 0;
+        this.setData = (data) => {
+            const { sortBy, sortOrder, comparator } = this.state;
+            data = [...data];
+            if (sortBy) {
+                let c = comparator;
+                if (c && sortOrder === SORT_DESC)
+                    c = Comparators.inverse(c);
+                data.sort(c || Comparators.of(sortBy, sortOrder, data));
+            }
+            this.setState({ data }, () => {
+                orNoop(this.props.onSortChange)(sortBy, sortOrder);
+            });
+        };
+        this.updateHeaders = () => {
+            const headers = this.headers();
+            const hidden = headers.querySelectorAll('.hidden');
+            const fixed = headers.querySelectorAll('.fixed');
+            for (let i = 0; i < hidden.length; i++) {
+                fixed[i].style.width = hidden[i].offsetWidth + 'px';
+            }
+        };
+        this.cancelEditing = () => this.setState({ editing: false });
+        this.setEditing = (item, columnIndex, field) => this.setState({ editing: this.prepareEditing(item, field, columnIndex) });
+        this.prepareEditing = (item, field, columnIndex) => ({ id: item.id, value: item[field], columnIndex, item, field });
+        this.handleInputChange = (event) => {
+            const value = this.extractValue(event);
+            this.setState({ editing: __extends(__extends({}, this.state.editing), { value }) });
+        };
+        this.extractValue = (event) => {
+            const target = event.target;
+            return target.type === 'checkbox' ? target.checked : target.value;
+        };
+        this.selectNewValue = (value) => {
+            this.setState({ editing: __extends(__extends({}, this.state.editing), { value }) }, this.onFinishEditing);
+        };
+        this.onFinishEditing = () => {
+            const editing = this.state.editing;
+            if (editing.value === null)
+                return;
+            let value = editing.value;
+            if (isString(value))
+                value = value.trim();
+            if (value === editing.item[editing.field])
+                return this.cancelEditing();
+            let updated = __extends(__extends({}, editing.item), { [editing.field]: value });
+            this.props.onChange(updated, this.cancelEditing);
+        };
+        this.sort = (e, sortBy, comparator) => {
+            preventDefault(e);
+            this.setState({
+                sortOrder: this.state.sortBy === sortBy && this.state.sortOrder === SORT_ASC ? SORT_DESC : SORT_ASC,
+                comparator,
+                sortBy
+            }, () => this.setData(this.state.data));
+        };
+        this.state = {};
     }
-  }, {
-    key: "componentDidUpdate",
-    value: function componentDidUpdate(prevProps, prevState, snapshot) {
-      var _this3 = this;
-      var _this$props2 = this.props,
-          sortBy = _this$props2.sortBy,
-          sortOrder = _this$props2.sortOrder,
-          columns = _this$props2.columns,
-          data = _this$props2.data;
-      if (sortBy !== prevProps.sortBy || sortOrder !== prevProps.sortOrder) {
-        var _columns$find2;
+    componentDidMount() {
+        var _a;
+        const { sortBy, sortOrder = SORT_ASC, columns } = this.props;
         this.setState({
-          sortBy: sortBy,
-          sortOrder: sortOrder || SORT_ASC,
-          comparator: (_columns$find2 = columns.find(function (it) {
-            return it.field === sortBy;
-          })) == null ? void 0 : _columns$find2.comparator
-        }, function () {
-          return _this3.setData(data);
-        });
-      } else if (data !== prevProps.data) {
-        this.setData(data);
-      }
-      this.updateHeaders();
+            sortBy,
+            sortOrder,
+            comparator: (_a = columns.find(it => it.field === sortBy)) === null || _a === void 0 ? void 0 : _a.comparator
+        }, () => this.setData(this.props.data));
+        this.updateHeaders();
+        this.updateHeadersInterval = setInterval(this.updateHeaders, 1000);
     }
-  }, {
-    key: "render",
-    value: function render() {
-      var _this4 = this;
-      var _this$props3 = this.props,
-          _this$props3$columns = _this$props3.columns,
-          columns = _this$props3$columns === void 0 ? [] : _this$props3$columns,
-          _this$props3$onRowCli = _this$props3.onRowClick,
-          onRowClick = _this$props3$onRowCli === void 0 ? NOOP : _this$props3$onRowCli,
-          disabled = _this$props3.disabled,
-          className = _this$props3.className,
-          rowClassName = _this$props3.rowClassName,
-          _this$props3$toKey = _this$props3.toKey,
-          toKey = _this$props3$toKey === void 0 ? getId : _this$props3$toKey;
-      var _this$state2 = this.state,
-          sortBy = _this$state2.sortBy,
-          sortOrder = _this$state2.sortOrder,
-          _this$state2$data = _this$state2.data,
-          data = _this$state2$data === void 0 ? [] : _this$state2$data,
-          editing = _this$state2.editing;
-      return ReactCreateElement("table", {
-        className: classNames("Table", className)
-      }, ReactCreateElement("thead", null, ReactCreateElement("tr", {
-        ref: function ref(headers) {
-          return _this4.headers = headers;
+    ;
+    componentDidUpdate(prevProps, prevState, snapshot) {
+        var _a;
+        const { sortBy, sortOrder, columns, data } = this.props;
+        if (sortBy !== prevProps.sortBy || sortOrder !== prevProps.sortOrder) {
+            this.setState({
+                sortBy,
+                sortOrder: sortOrder || SORT_ASC,
+                comparator: (_a = columns.find(it => it.field === sortBy)) === null || _a === void 0 ? void 0 : _a.comparator
+            }, () => this.setData(data));
+        }
+        else if (data !== prevProps.data) {
+            this.setData(data);
         }
-      }, columns.filter(function (it) {
-        return !!it;
-      }).map(function (column, i) {
-        var sortable = column.sortable || column.sortable == null;
-        return ReactCreateElement("th", {
-          key: i,
-          onClick: function onClick(e) {
-            return sortable && _this4.sort(e, column.field, column.comparator);
-          }
-        }, ReactCreateElement("div", {
-          className: classNames('hidden', sortable && 'sortable', sortBy === column.field && 'active')
-        }, column.header, column.header && sortBy === column.field && sortOrder === SORT_ASC && ReactCreateElement(MaterialIcon, {
-          icon: 'keyboard_arrow_up'
-        }), column.header && sortBy === column.field && sortOrder === SORT_DESC && ReactCreateElement(MaterialIcon, {
-          icon: 'keyboard_arrow_down'
-        })), ReactCreateElement("div", {
-          className: classNames('fixed', sortable && 'sortable', sortBy === column.field && 'active')
-        }, column.header, column.header && sortBy === column.field && sortOrder === SORT_ASC && ReactCreateElement(MaterialIcon, {
-          icon: 'keyboard_arrow_up'
-        }), column.header && sortBy === column.field && sortOrder === SORT_DESC && ReactCreateElement(MaterialIcon, {
-          icon: 'keyboard_arrow_down'
-        })));
-      }))), ReactCreateElement("tbody", null, data.map(function (item) {
-        return ReactCreateElement(Row, {
-          key: toKey(item),
-          item: item,
-          disabled: disabled,
-          editing: editing && editing.id === item.id ? editing : null,
-          onClick: onRowClick,
-          className: rowClassName,
-          columns: columns,
-          editingContext: _this4
-        });
-      })));
+        this.updateHeaders();
+    }
+    ;
+    render() {
+        const { columns = [], onRowClick = NOOP, disabled, className, rowClassName, toKey = getId } = this.props;
+        const { sortBy, sortOrder, data = [], editing } = this.state;
+        return (jsxRuntime_1("table", __extends({ [__className]: classNames(`Table`, className) }, { [__children]: [jsxRuntime_2("thead", { [__children]: jsxRuntime_2("tr", __extends({ ref: this.headers }, { [__children]: columns.filter(it => !!it).map((column, i) => {
+                            const sortable = column.sortable || column.sortable == null;
+                            return (jsxRuntime_1("th", __extends({ onClick: e => sortable && this.sort(e, column.field, column.comparator) }, { [__children]: [jsxRuntime_1("div", __extends({ [__className]: classNames('hidden', sortable && 'sortable', sortBy === column.field && 'active') }, { [__children]: [column.header, column.header && sortBy === column.field && sortOrder === SORT_ASC && (jsxRuntime_2(MaterialIcon, { icon: 'keyboard_arrow_up' })), column.header && sortBy === column.field && sortOrder === SORT_DESC && (jsxRuntime_2(MaterialIcon, { icon: 'keyboard_arrow_down' }))] })), jsxRuntime_1("div", __extends({ [__className]: classNames('fixed', sortable && 'sortable', sortBy === column.field && 'active') }, { [__children]: [column.header, column.header && sortBy === column.field && sortOrder === SORT_ASC && (jsxRuntime_2(MaterialIcon, { icon: 'keyboard_arrow_up' })), column.header && sortBy === column.field && sortOrder === SORT_DESC && (jsxRuntime_2(MaterialIcon, { icon: 'keyboard_arrow_down' }))] }))] }), i));
+                        }) })) }), jsxRuntime_2("tbody", { [__children]: data.map(item => (jsxRuntime_2(Row, { item: item, disabled: disabled, editing: editing && editing.id === item.id ? editing : null, onClick: onRowClick, [__className]: rowClassName, columns: columns, editingContext: this }, toKey(item)))) })] })));
+    }
+    ;
+    componentWillUnmount() {
+        clearInterval(this.updateHeadersInterval);
+    }
+    ;
+}
+const formatValue = (item, column) => {
+    const value = (column.value !== undefined) ? column.value : item[column.field];
+    if (column.formatter) {
+        return column.formatter(value, item, column.format);
     }
-  }, {
-    key: "componentWillUnmount",
-    value: function componentWillUnmount() {
-      clearInterval(this.updateHeadersInterval);
+    else {
+        return '' + value;
     }
-  }]);
-  return Table;
-}(Component);
-var formatValue = function formatValue(item, column) {
-  var value = column.value !== undefined ? column.value : item[column.field];
-  if (column.formatter) {
-    return column.formatter(value, item, column.format);
-  } else {
-    return '' + value;
-  }
 };
-var Row = React.memo(function (_ref) {
-  var item = _ref.item,
-      disabled = _ref.disabled,
-      editing = _ref.editing,
-      _onClick = _ref.onClick,
-      className = _ref.className,
-      columns = _ref.columns,
-      editingContext = _ref.editingContext;
-  return ReactCreateElement("tr", {
-    onClick: function onClick(e) {
-      return _onClick(item);
-    },
-    className: classNames(disabled && disabled(item) && 'disabled', className && (isFunction(className) ? className(item) : className))
-  }, columns.filter(function (it) {
-    return !!it;
-  }).map(function (column, i) {
-    var isEditing = editing && editing.id === item.id && editing.columnIndex === i;
-    var editable = isFunction(column.editable) ? column.editable(item) : !!column.editable;
-    return ReactCreateElement("td", {
-      key: i,
-      className: classNames(editable ? 'editable' : 'ro', isEditing && 'editing', column.className),
-      onClick: !isEditing && editable ? function () {
-        return editingContext.setEditing(item, i, column.field);
-      } : NOOP
-    }, (isEditing || column.displayEditor) && !column.editor && ReactCreateElement(TextField, {
-      value: column.preEditor ? column.preEditor(editing.value) : editing.value,
-      focused: true,
-      onBlur: editingContext.cancelEditing,
-      onChange: editingContext.handleInputChange,
-      onKeyDown: function onKeyDown(e) {
-        if (e.keyCode === 27
-        ) {
-          preventDefault(e);
-          editingContext.cancelEditing();
-        }
-        if (e.keyCode === 13
-        ) {
-          preventDefault(e);
-          editingContext.onFinishEditing();
-        }
-      }
-    }), (isEditing || column.displayEditor) && column.editor === 'Select' && ReactCreateElement(AutocompleteSelect, {
-      value: column.preEditor ? column.preEditor(editing.value) : editing.value,
-      data: column.editorData,
-      focused: true,
-      withArrow: false,
-      withFilter: false,
-      selectedMode: 'inline',
-      selectedComponent: column.editorSelectedComponent,
-      mode: column.multiSelect ? MODE_MULTIPLE_MINI : MODE_DEFAULT,
-      onChange: column.multiSelect && (column.onSelect ? function (value) {
-        return editingContext.selectNewValue(column.onSelect(value));
-      } : editingContext.selectNewValue),
-      onSelect: !column.multiSelect && (column.onSelect ? function (value) {
-        return editingContext.selectNewValue(column.onSelect(value));
-      } : editingContext.selectNewValue),
-      childComponent: column.editorChildCompononRowClickent,
-      onCancel: editingContext.cancelEditing,
-      prefilter: column.prefilter
-    }), (isEditing || column.displayEditor) && column.editor === 'Switch' && ReactCreateElement(Switch, {
-      onClick: function onClick(e) {
-        stopPropagation(e);
-        preventDefault(e);
-        editingContext.setState({
-          editing: _objectSpread2(_objectSpread2({}, editingContext.prepareEditing(item, column.field, i)), {}, {
-            value: !item[column.field]
-          })
-        }, editingContext.onFinishEditing);
-      },
-      value: item[column.field]
-    }), (isEditing || column.displayEditor) && isFunction(column.editor) && column.editor(item, editingContext.cancelEditing, isEditing), !isEditing && !column.displayEditor && formatValue(item, column));
-  }));
+const Row = React.memo(({ item, disabled, editing, onClick, className, columns, editingContext }) => {
+    return jsxRuntime_2("tr", __extends({ onClick: e => onClick(item), [__className]: classNames(disabled && disabled(item) && 'disabled', className && (isFunction(className) ? className(item) : className)) }, { [__children]: columns.filter(it => !!it).map((column, i) => {
+            const isEditing = editing && editing.id === item.id && editing.columnIndex === i;
+            const editable = isFunction(column.editable) ? column.editable(item) : !!column.editable;
+            return (jsxRuntime_1("td", __extends({ [__className]: classNames(editable ? 'editable' : 'ro', isEditing && 'editing', column.className), onClick: !isEditing && editable ? () => editingContext.setEditing(item, i, column.field) : NOOP }, { [__children]: [(isEditing || column.displayEditor) && !column.editor && (jsxRuntime_2(TextField, { value: column.preEditor ? column.preEditor(editing.value) : editing.value, focused: true, onBlur: editingContext.cancelEditing, onChange: editingContext.handleInputChange, onKeyDown: e => {
+                            if (e.keyCode === 27 /*escape*/) {
+                                preventDefault(e);
+                                editingContext.cancelEditing();
+                            }
+                            if (e.keyCode === 13 /*enter*/) {
+                                preventDefault(e);
+                                editingContext.onFinishEditing();
+                            }
+                        } })), (isEditing || column.displayEditor) && column.editor === editorSelect && (jsxRuntime_2(AutocompleteSelect, { value: column.preEditor ? column.preEditor(editing.value) : editing.value, data: column.editorData, focused: true, withArrow: false, withFilter: false, selectedMode: 'inline', selectedComponent: column.editorSelectedComponent, mode: column.multiSelect ? MODE_MULTIPLE_MINI : MODE_DEFAULT, onChange: column.multiSelect && (column.onSelect ? (value => editingContext.selectNewValue(column.onSelect(value))) : editingContext.selectNewValue), onSelect: !column.multiSelect && (column.onSelect ? (value => editingContext.selectNewValue(column.onSelect(value))) : editingContext.selectNewValue), childComponent: column.editorChildCompononRowClickent, onCancel: editingContext.cancelEditing, prefilter: column.prefilter })), (isEditing || column.displayEditor) && column.editor === editorSwitch && (jsxRuntime_2(Switch, { onClick: e => {
+                            stopPropagation(e);
+                            preventDefault(e);
+                            editingContext.setState({
+                                editing: __extends(__extends({}, editingContext.prepareEditing(item, column.field, i)), { value: !item[column.field] })
+                            }, editingContext.onFinishEditing);
+                        }, value: item[column.field] })), (isEditing || column.displayEditor) && isFunction(column.editor) && column.editor(item, editingContext.cancelEditing, isEditing), !isEditing && !column.displayEditor && formatValue(item, column)] }), i));
+        }) }));
 });
-Table.defaultProps = {
-  columns: [],
-  onRowClick: NOOP,
-  toKey: getId
-};
-if (process.env.NODE_ENV !== 'production') {
-  Table.propTypes = {
-    className: PropTypes.string,
-    rowClassName: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
-    columns: PropTypes.arrayOf(PropTypes.shape({
-      header: PropTypes.oneOfType([PropTypes.string, PropTypes.element]),
-      className: PropTypes.string,
-      sortable: PropTypes.bool,
-      field: PropTypes.string,
-      formatter: PropTypes.func,
-      comparator: PropTypes.func,
-      editable: PropTypes.oneOfType([PropTypes.bool, PropTypes.func]),
-      editor: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
-      displayEditor: PropTypes.bool,
-      preEditor: PropTypes.func
-    })),
-    data: PropTypes.array,
-    disabled: PropTypes.func,
-    onRowClick: PropTypes.func,
-    onSortChange: PropTypes.func,
-    onChange: PropTypes.func,
-    toKey: PropTypes.func
-  };
-}
-var Table$1 = Table;
 
-export { SORT_ASC, SORT_DESC, Table$1 as default };
+export { SORT_ASC, SORT_DESC, Table as default };
 //# sourceMappingURL=Table.js.map