@murasoftware/react-bootstrap-table-next - npm Package Compare versions

Comparing version 4.1.3 to 4.1.4

lib/index.js

@@ -1,3 +0,17 @@
-import BootstrapTable from './src/bootstrap-table';
-import withContext from './src/contexts';
-export default withContext(BootstrapTable);
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _bootstrapTable = require('./src/bootstrap-table');
+
+var _bootstrapTable2 = _interopRequireDefault(_bootstrapTable);
+
+var _contexts = require('./src/contexts');
+
+var _contexts2 = _interopRequireDefault(_contexts);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = (0, _contexts2.default)(_bootstrapTable2.default);

lib/src/body.js

@@ -1,127 +0,180 @@
-/* eslint react/prop-types: 0 */
+'use strict';
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _utils = require('./utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+var _simpleRow = require('./row/simple-row');
+
+var _simpleRow2 = _interopRequireDefault(_simpleRow);
+
+var _aggregateRow = require('./row/aggregate-row');
+
+var _aggregateRow2 = _interopRequireDefault(_aggregateRow);
+
+var _rowSection = require('./row/row-section');
+
+var _rowSection2 = _interopRequireDefault(_rowSection);
+
+var _const = require('./const');
+
+var _const2 = _interopRequireDefault(_const);
+
+var _rowConsumer = require('./row-selection/row-consumer');
+
+var _rowConsumer2 = _interopRequireDefault(_rowConsumer);
+
+var _rowConsumer3 = require('./row-expand/row-consumer');
+
+var _rowConsumer4 = _interopRequireDefault(_rowConsumer3);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint react/prop-types: 0 */
 /* eslint react/require-default-props: 0 */
-import React from 'react';
-import PropTypes from 'prop-types';
-import _ from './utils';
-import SimpleRow from './row/simple-row';
-import RowAggregator from './row/aggregate-row';
-import RowSection from './row/row-section';
-import Const from './const';
-import withRowSelection from './row-selection/row-consumer';
-import withRowExpansion from './row-expand/row-consumer';
 
-class Body extends React.Component {
-  constructor(props) {
-    super(props);
-    const {
-      keyField,
-      cellEdit,
-      selectRow,
-      expandRow
-    } = props; // Construct Editing Cell Component
+var Body = function (_React$Component) {
+  _inherits(Body, _React$Component);
 
+  function Body(props) {
+    _classCallCheck(this, Body);
+
+    var _this = _possibleConstructorReturn(this, (Body.__proto__ || Object.getPrototypeOf(Body)).call(this, props));
+
+    var keyField = props.keyField,
+        cellEdit = props.cellEdit,
+        selectRow = props.selectRow,
+        expandRow = props.expandRow;
+
+    // Construct Editing Cell Component
+
     if (cellEdit.createContext) {
-      this.EditingCell = cellEdit.createEditingCell(_, cellEdit.options.onStartEdit);
-    } // Construct Row Component
+      _this.EditingCell = cellEdit.createEditingCell(_utils2.default, cellEdit.options.onStartEdit);
+    }
 
+    // Construct Row Component
+    var RowComponent = _simpleRow2.default;
+    var selectRowEnabled = selectRow.mode !== _const2.default.ROW_SELECT_DISABLED;
+    var expandRowEnabled = !!expandRow.renderer;
 
-    let RowComponent = SimpleRow;
-    const selectRowEnabled = selectRow.mode !== Const.ROW_SELECT_DISABLED;
-    const expandRowEnabled = !!expandRow.renderer;
-
     if (expandRowEnabled) {
-      RowComponent = withRowExpansion(RowAggregator);
+      RowComponent = (0, _rowConsumer4.default)(_aggregateRow2.default);
     }
 
     if (selectRowEnabled) {
-      RowComponent = withRowSelection(expandRowEnabled ? RowComponent : RowAggregator);
+      RowComponent = (0, _rowConsumer2.default)(expandRowEnabled ? RowComponent : _aggregateRow2.default);
     }
 
     if (cellEdit.createContext) {
-      RowComponent = cellEdit.withRowLevelCellEdit(RowComponent, selectRowEnabled, keyField, _);
+      RowComponent = cellEdit.withRowLevelCellEdit(RowComponent, selectRowEnabled, keyField, _utils2.default);
     }
-
-    this.RowComponent = RowComponent;
+    _this.RowComponent = RowComponent;
+    return _this;
   }
 
-  render() {
-    const {
-      columns,
-      data,
-      tabIndexCell,
-      keyField,
-      isEmpty,
-      noDataIndication,
-      visibleColumnSize,
-      cellEdit,
-      selectRow,
-      rowStyle,
-      rowClasses,
-      rowEvents,
-      expandRow,
-      className
-    } = this.props;
-    let content;
+  _createClass(Body, [{
+    key: 'render',
+    value: function render() {
+      var _this2 = this;
 
-    if (isEmpty) {
-      const indication = _.isFunction(noDataIndication) ? noDataIndication() : noDataIndication;
+      var _props = this.props,
+          columns = _props.columns,
+          data = _props.data,
+          tabIndexCell = _props.tabIndexCell,
+          keyField = _props.keyField,
+          isEmpty = _props.isEmpty,
+          noDataIndication = _props.noDataIndication,
+          visibleColumnSize = _props.visibleColumnSize,
+          cellEdit = _props.cellEdit,
+          selectRow = _props.selectRow,
+          rowStyle = _props.rowStyle,
+          rowClasses = _props.rowClasses,
+          rowEvents = _props.rowEvents,
+          expandRow = _props.expandRow,
+          className = _props.className;
 
-      if (!indication) {
-        return null;
-      }
 
-      content = /*#__PURE__*/React.createElement(RowSection, {
-        content: indication,
-        colSpan: visibleColumnSize
-      });
-    } else {
-      const selectRowEnabled = selectRow.mode !== Const.ROW_SELECT_DISABLED;
-      const expandRowEnabled = !!expandRow.renderer;
-      const additionalRowProps = {};
+      var content = void 0;
 
-      if (cellEdit.createContext) {
-        additionalRowProps.EditingCellComponent = this.EditingCell;
-      }
+      if (isEmpty) {
+        var indication = _utils2.default.isFunction(noDataIndication) ? noDataIndication() : noDataIndication;
+        if (!indication) {
+          return null;
+        }
+        content = _react2.default.createElement(_rowSection2.default, { content: indication, colSpan: visibleColumnSize });
+      } else {
+        var selectRowEnabled = selectRow.mode !== _const2.default.ROW_SELECT_DISABLED;
+        var expandRowEnabled = !!expandRow.renderer;
 
-      if (selectRowEnabled || expandRowEnabled) {
-        additionalRowProps.expandRow = expandRow;
-        additionalRowProps.selectRow = selectRow;
+        var additionalRowProps = {};
+
+        if (cellEdit.createContext) {
+          additionalRowProps.EditingCellComponent = this.EditingCell;
+        }
+
+        if (selectRowEnabled || expandRowEnabled) {
+          additionalRowProps.expandRow = expandRow;
+          additionalRowProps.selectRow = selectRow;
+        }
+
+        content = data.map(function (row, index) {
+          var key = _utils2.default.get(row, keyField);
+          var baseRowProps = _extends({
+            key: key,
+            row: row,
+            tabIndexCell: tabIndexCell,
+            columns: columns,
+            keyField: keyField,
+            cellEdit: cellEdit,
+            value: key,
+            rowIndex: index,
+            visibleColumnSize: visibleColumnSize,
+            attrs: rowEvents || {}
+          }, additionalRowProps);
+
+          baseRowProps.style = _utils2.default.isFunction(rowStyle) ? rowStyle(row, index) : rowStyle;
+          baseRowProps.className = _utils2.default.isFunction(rowClasses) ? rowClasses(row, index) : rowClasses;
+
+          return _react2.default.createElement(_this2.RowComponent, baseRowProps);
+        });
       }
 
-      content = data.map((row, index) => {
-        const key = _.get(row, keyField);
-
-        const baseRowProps = {
-          key,
-          row,
-          tabIndexCell,
-          columns,
-          keyField,
-          cellEdit,
-          value: key,
-          rowIndex: index,
-          visibleColumnSize,
-          attrs: rowEvents || {},
-          ...additionalRowProps
-        };
-        baseRowProps.style = _.isFunction(rowStyle) ? rowStyle(row, index) : rowStyle;
-        baseRowProps.className = _.isFunction(rowClasses) ? rowClasses(row, index) : rowClasses;
-        return /*#__PURE__*/React.createElement(this.RowComponent, baseRowProps);
-      });
+      return _react2.default.createElement(
+        'tbody',
+        { className: className },
+        content
+      );
     }
+  }]);
 
-    return /*#__PURE__*/React.createElement("tbody", {
-      className: className
-    }, content);
-  }
+  return Body;
+}(_react2.default.Component);
 
-}
-
 Body.propTypes = {
-  keyField: PropTypes.string.isRequired,
-  data: PropTypes.array.isRequired,
-  columns: PropTypes.array.isRequired,
-  selectRow: PropTypes.object
+  keyField: _propTypes2.default.string.isRequired,
+  data: _propTypes2.default.array.isRequired,
+  columns: _propTypes2.default.array.isRequired,
+  selectRow: _propTypes2.default.object
 };
-export default Body;
+
+exports.default = Body;

lib/src/bootstrap-table.js

@@ -1,231 +0,312 @@
-/* eslint camelcase: 0 */
+'use strict';
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _classnames = require('classnames');
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
+var _header = require('./header');
+
+var _header2 = _interopRequireDefault(_header);
+
+var _filters = require('./filters');
+
+var _filters2 = _interopRequireDefault(_filters);
+
+var _caption = require('./caption');
+
+var _caption2 = _interopRequireDefault(_caption);
+
+var _body = require('./body');
+
+var _body2 = _interopRequireDefault(_body);
+
+var _footer = require('./footer');
+
+var _footer2 = _interopRequireDefault(_footer);
+
+var _propsResolver = require('./props-resolver');
+
+var _propsResolver2 = _interopRequireDefault(_propsResolver);
+
+var _const = require('./const');
+
+var _const2 = _interopRequireDefault(_const);
+
+var _utils = require('./utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint camelcase: 0 */
 /* eslint arrow-body-style: 0 */
-import React, { Component } from 'react';
-import PropTypes from 'prop-types';
-import cs from 'classnames';
-import Header from './header';
-import Filters from './filters';
-import Caption from './caption';
-import Body from './body';
-import Footer from './footer';
-import PropsBaseResolver from './props-resolver';
-import Const from './const';
-import _ from './utils';
 
-class BootstrapTable extends PropsBaseResolver(Component) {
-  constructor(props) {
-    super(props);
-    this.validateProps();
+var BootstrapTable = function (_PropsBaseResolver) {
+  _inherits(BootstrapTable, _PropsBaseResolver);
+
+  function BootstrapTable(props) {
+    _classCallCheck(this, BootstrapTable);
+
+    var _this = _possibleConstructorReturn(this, (BootstrapTable.__proto__ || Object.getPrototypeOf(BootstrapTable)).call(this, props));
+
+    _this.getData = function () {
+      return _this.visibleRows();
+    };
+
+    _this.validateProps();
+    return _this;
   }
 
-  UNSAFE_componentWillReceiveProps(nextProps) {
-    if (nextProps.onDataSizeChange && !nextProps.pagination) {
-      if (nextProps.data.length !== this.props.data.length) {
-        nextProps.onDataSizeChange({
-          dataSize: nextProps.data.length
-        });
+  _createClass(BootstrapTable, [{
+    key: 'UNSAFE_componentWillReceiveProps',
+    value: function UNSAFE_componentWillReceiveProps(nextProps) {
+      if (nextProps.onDataSizeChange && !nextProps.pagination) {
+        if (nextProps.data.length !== this.props.data.length) {
+          nextProps.onDataSizeChange({ dataSize: nextProps.data.length });
+        }
       }
     }
-  } // Exposed APIs
 
+    // Exposed APIs
 
-  getData = () => {
-    return this.visibleRows();
-  };
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          loading = _props.loading,
+          overlay = _props.overlay;
 
-  render() {
-    const {
-      loading,
-      overlay
-    } = this.props;
-
-    if (overlay) {
-      const LoadingOverlay = overlay(loading);
-      return /*#__PURE__*/React.createElement(LoadingOverlay, null, this.renderTable());
+      if (overlay) {
+        var LoadingOverlay = overlay(loading);
+        return _react2.default.createElement(
+          LoadingOverlay,
+          null,
+          this.renderTable()
+        );
+      }
+      return this.renderTable();
     }
+  }, {
+    key: 'renderTable',
+    value: function renderTable() {
+      var _props2 = this.props,
+          columns = _props2.columns,
+          keyField = _props2.keyField,
+          tabIndexCell = _props2.tabIndexCell,
+          id = _props2.id,
+          classes = _props2.classes,
+          bootstrap4 = _props2.bootstrap4,
+          striped = _props2.striped,
+          hover = _props2.hover,
+          bordered = _props2.bordered,
+          condensed = _props2.condensed,
+          noDataIndication = _props2.noDataIndication,
+          caption = _props2.caption,
+          rowStyle = _props2.rowStyle,
+          rowClasses = _props2.rowClasses,
+          wrapperClasses = _props2.wrapperClasses,
+          rowEvents = _props2.rowEvents,
+          selectRow = _props2.selectRow,
+          expandRow = _props2.expandRow,
+          cellEdit = _props2.cellEdit,
+          filterPosition = _props2.filterPosition;
 
-    return this.renderTable();
-  }
 
-  renderTable() {
-    const {
-      columns,
-      keyField,
-      tabIndexCell,
-      id,
-      classes,
-      bootstrap4,
-      striped,
-      hover,
-      bordered,
-      condensed,
-      noDataIndication,
-      caption,
-      rowStyle,
-      rowClasses,
-      wrapperClasses,
-      rowEvents,
-      selectRow,
-      expandRow,
-      cellEdit,
-      filterPosition
-    } = this.props;
-    const tableWrapperClass = cs('react-bootstrap-table', wrapperClasses);
-    const tableClass = cs('table', {
-      'table-striped': striped,
-      'table-hover': hover,
-      'table-bordered': bordered,
-      [bootstrap4 ? 'table-sm' : 'table-condensed']: condensed
-    }, classes);
-    const hasFilters = columns.some(col => col.filter || col.filterRenderer);
-    const hasFooter = _.filter(columns, col => _.has(col, 'footer')).length > 0;
-    const tableCaption = caption && /*#__PURE__*/React.createElement(Caption, {
-      bootstrap4: bootstrap4
-    }, caption);
-    return /*#__PURE__*/React.createElement("div", {
-      className: tableWrapperClass
-    }, /*#__PURE__*/React.createElement("table", {
-      id: id,
-      className: tableClass
-    }, tableCaption, /*#__PURE__*/React.createElement(Header, {
-      columns: columns,
-      className: this.props.headerClasses,
-      wrapperClasses: this.props.headerWrapperClasses,
-      sortField: this.props.sortField,
-      sortOrder: this.props.sortOrder,
-      onSort: this.props.onSort,
-      globalSortCaret: this.props.sort && this.props.sort.sortCaret,
-      onFilter: this.props.onFilter,
-      currFilters: this.props.currFilters,
-      onExternalFilter: this.props.onExternalFilter,
-      selectRow: selectRow,
-      expandRow: expandRow,
-      filterPosition: filterPosition
-    }), hasFilters && filterPosition !== Const.FILTERS_POSITION_INLINE && /*#__PURE__*/React.createElement(Filters, {
-      columns: columns,
-      className: this.props.filtersClasses,
-      onSort: this.props.onSort,
-      onFilter: this.props.onFilter,
-      currFilters: this.props.currFilters,
-      filterPosition: this.props.filterPosition,
-      onExternalFilter: this.props.onExternalFilter,
-      selectRow: selectRow,
-      expandRow: expandRow
-    }), /*#__PURE__*/React.createElement(Body, {
-      className: this.props.bodyClasses,
-      data: this.getData(),
-      keyField: keyField,
-      tabIndexCell: tabIndexCell,
-      columns: columns,
-      isEmpty: this.isEmpty(),
-      visibleColumnSize: this.visibleColumnSize(),
-      noDataIndication: noDataIndication,
-      cellEdit: cellEdit,
-      selectRow: selectRow,
-      expandRow: expandRow,
-      rowStyle: rowStyle,
-      rowClasses: rowClasses,
-      rowEvents: rowEvents
-    }), hasFooter && /*#__PURE__*/React.createElement(Footer, {
-      data: this.getData(),
-      columns: columns,
-      selectRow: selectRow,
-      expandRow: expandRow,
-      className: this.props.footerClasses
-    })));
-  }
+      var tableWrapperClass = (0, _classnames2.default)('react-bootstrap-table', wrapperClasses);
 
-}
+      var tableClass = (0, _classnames2.default)('table', _defineProperty({
+        'table-striped': striped,
+        'table-hover': hover,
+        'table-bordered': bordered
+      }, bootstrap4 ? 'table-sm' : 'table-condensed', condensed), classes);
 
+      var hasFilters = columns.some(function (col) {
+        return col.filter || col.filterRenderer;
+      });
+
+      var hasFooter = _utils2.default.filter(columns, function (col) {
+        return _utils2.default.has(col, 'footer');
+      }).length > 0;
+
+      var tableCaption = caption && _react2.default.createElement(
+        _caption2.default,
+        { bootstrap4: bootstrap4 },
+        caption
+      );
+
+      return _react2.default.createElement(
+        'div',
+        { className: tableWrapperClass },
+        _react2.default.createElement(
+          'table',
+          { id: id, className: tableClass },
+          tableCaption,
+          _react2.default.createElement(_header2.default, {
+            columns: columns,
+            className: this.props.headerClasses,
+            wrapperClasses: this.props.headerWrapperClasses,
+            sortField: this.props.sortField,
+            sortOrder: this.props.sortOrder,
+            onSort: this.props.onSort,
+            globalSortCaret: this.props.sort && this.props.sort.sortCaret,
+            onFilter: this.props.onFilter,
+            currFilters: this.props.currFilters,
+            onExternalFilter: this.props.onExternalFilter,
+            selectRow: selectRow,
+            expandRow: expandRow,
+            filterPosition: filterPosition
+          }),
+          hasFilters && filterPosition !== _const2.default.FILTERS_POSITION_INLINE && _react2.default.createElement(_filters2.default, {
+            columns: columns,
+            className: this.props.filtersClasses,
+            onSort: this.props.onSort,
+            onFilter: this.props.onFilter,
+            currFilters: this.props.currFilters,
+            filterPosition: this.props.filterPosition,
+            onExternalFilter: this.props.onExternalFilter,
+            selectRow: selectRow,
+            expandRow: expandRow
+          }),
+          _react2.default.createElement(_body2.default, {
+            className: this.props.bodyClasses,
+            data: this.getData(),
+            keyField: keyField,
+            tabIndexCell: tabIndexCell,
+            columns: columns,
+            isEmpty: this.isEmpty(),
+            visibleColumnSize: this.visibleColumnSize(),
+            noDataIndication: noDataIndication,
+            cellEdit: cellEdit,
+            selectRow: selectRow,
+            expandRow: expandRow,
+            rowStyle: rowStyle,
+            rowClasses: rowClasses,
+            rowEvents: rowEvents
+          }),
+          hasFooter && _react2.default.createElement(_footer2.default, {
+            data: this.getData(),
+            columns: columns,
+            selectRow: selectRow,
+            expandRow: expandRow,
+            className: this.props.footerClasses
+          })
+        )
+      );
+    }
+  }]);
+
+  return BootstrapTable;
+}((0, _propsResolver2.default)(_react.Component));
+
 BootstrapTable.propTypes = {
-  keyField: PropTypes.string.isRequired,
-  data: PropTypes.array.isRequired,
-  columns: PropTypes.array.isRequired,
-  bootstrap4: PropTypes.bool,
-  remote: PropTypes.oneOfType([PropTypes.bool, PropTypes.shape({
-    pagination: PropTypes.bool
+  keyField: _propTypes2.default.string.isRequired,
+  data: _propTypes2.default.array.isRequired,
+  columns: _propTypes2.default.array.isRequired,
+  bootstrap4: _propTypes2.default.bool,
+  remote: _propTypes2.default.oneOfType([_propTypes2.default.bool, _propTypes2.default.shape({
+    pagination: _propTypes2.default.bool
   })]),
-  noDataIndication: PropTypes.oneOfType([PropTypes.node, PropTypes.func]),
-  striped: PropTypes.bool,
-  bordered: PropTypes.bool,
-  hover: PropTypes.bool,
-  tabIndexCell: PropTypes.bool,
-  id: PropTypes.string,
-  classes: PropTypes.string,
-  headerClasses: PropTypes.string,
-  bodyClasses: PropTypes.string,
-  wrapperClasses: PropTypes.string,
-  headerWrapperClasses: PropTypes.string,
-  condensed: PropTypes.bool,
-  caption: PropTypes.oneOfType([PropTypes.node, PropTypes.string]),
-  pagination: PropTypes.object,
-  filter: PropTypes.object,
-  cellEdit: PropTypes.object,
-  selectRow: PropTypes.shape({
-    mode: PropTypes.oneOf([Const.ROW_SELECT_SINGLE, Const.ROW_SELECT_MULTIPLE, Const.ROW_SELECT_DISABLED]).isRequired,
-    clickToSelect: PropTypes.bool,
-    clickToExpand: PropTypes.bool,
-    clickToEdit: PropTypes.bool,
-    hideSelectAll: PropTypes.bool,
-    onSelect: PropTypes.func,
-    onSelectAll: PropTypes.func,
-    style: PropTypes.oneOfType([PropTypes.object, PropTypes.func]),
-    classes: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
-    nonSelectable: PropTypes.array,
-    nonSelectableStyle: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
-    nonSelectableClasses: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
-    bgColor: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
-    hideSelectColumn: PropTypes.bool,
-    selectionRenderer: PropTypes.func,
-    selectionHeaderRenderer: PropTypes.func,
-    headerColumnStyle: PropTypes.oneOfType([PropTypes.object, PropTypes.func]),
-    selectColumnStyle: PropTypes.oneOfType([PropTypes.object, PropTypes.func]),
-    selectColumnPosition: PropTypes.oneOf([Const.INDICATOR_POSITION_LEFT, Const.INDICATOR_POSITION_RIGHT])
+  noDataIndication: _propTypes2.default.oneOfType([_propTypes2.default.node, _propTypes2.default.func]),
+  striped: _propTypes2.default.bool,
+  bordered: _propTypes2.default.bool,
+  hover: _propTypes2.default.bool,
+  tabIndexCell: _propTypes2.default.bool,
+  id: _propTypes2.default.string,
+  classes: _propTypes2.default.string,
+  headerClasses: _propTypes2.default.string,
+  bodyClasses: _propTypes2.default.string,
+  wrapperClasses: _propTypes2.default.string,
+  headerWrapperClasses: _propTypes2.default.string,
+  condensed: _propTypes2.default.bool,
+  caption: _propTypes2.default.oneOfType([_propTypes2.default.node, _propTypes2.default.string]),
+  pagination: _propTypes2.default.object,
+  filter: _propTypes2.default.object,
+  cellEdit: _propTypes2.default.object,
+  selectRow: _propTypes2.default.shape({
+    mode: _propTypes2.default.oneOf([_const2.default.ROW_SELECT_SINGLE, _const2.default.ROW_SELECT_MULTIPLE, _const2.default.ROW_SELECT_DISABLED]).isRequired,
+    clickToSelect: _propTypes2.default.bool,
+    clickToExpand: _propTypes2.default.bool,
+    clickToEdit: _propTypes2.default.bool,
+    hideSelectAll: _propTypes2.default.bool,
+    onSelect: _propTypes2.default.func,
+    onSelectAll: _propTypes2.default.func,
+    style: _propTypes2.default.oneOfType([_propTypes2.default.object, _propTypes2.default.func]),
+    classes: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.func]),
+    nonSelectable: _propTypes2.default.array,
+    nonSelectableStyle: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.func]),
+    nonSelectableClasses: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.func]),
+    bgColor: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.func]),
+    hideSelectColumn: _propTypes2.default.bool,
+    selectionRenderer: _propTypes2.default.func,
+    selectionHeaderRenderer: _propTypes2.default.func,
+    headerColumnStyle: _propTypes2.default.oneOfType([_propTypes2.default.object, _propTypes2.default.func]),
+    selectColumnStyle: _propTypes2.default.oneOfType([_propTypes2.default.object, _propTypes2.default.func]),
+    selectColumnPosition: _propTypes2.default.oneOf([_const2.default.INDICATOR_POSITION_LEFT, _const2.default.INDICATOR_POSITION_RIGHT])
   }),
-  expandRow: PropTypes.shape({
-    renderer: PropTypes.func,
-    expanded: PropTypes.array,
-    onExpand: PropTypes.func,
-    onExpandAll: PropTypes.func,
-    nonExpandable: PropTypes.array,
-    showExpandColumn: PropTypes.bool,
-    onlyOneExpanding: PropTypes.bool,
-    expandByColumnOnly: PropTypes.bool,
-    expandColumnRenderer: PropTypes.func,
-    expandHeaderColumnRenderer: PropTypes.func,
-    expandColumnPosition: PropTypes.oneOf([Const.INDICATOR_POSITION_LEFT, Const.INDICATOR_POSITION_RIGHT]),
-    className: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
-    parentClassName: PropTypes.oneOfType([PropTypes.string, PropTypes.func])
+  expandRow: _propTypes2.default.shape({
+    renderer: _propTypes2.default.func,
+    expanded: _propTypes2.default.array,
+    onExpand: _propTypes2.default.func,
+    onExpandAll: _propTypes2.default.func,
+    nonExpandable: _propTypes2.default.array,
+    showExpandColumn: _propTypes2.default.bool,
+    onlyOneExpanding: _propTypes2.default.bool,
+    expandByColumnOnly: _propTypes2.default.bool,
+    expandColumnRenderer: _propTypes2.default.func,
+    expandHeaderColumnRenderer: _propTypes2.default.func,
+    expandColumnPosition: _propTypes2.default.oneOf([_const2.default.INDICATOR_POSITION_LEFT, _const2.default.INDICATOR_POSITION_RIGHT]),
+    className: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.func]),
+    parentClassName: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.func])
   }),
-  rowStyle: PropTypes.oneOfType([PropTypes.object, PropTypes.func]),
-  rowEvents: PropTypes.object,
-  rowClasses: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
-  filtersClasses: PropTypes.string,
-  filterPosition: PropTypes.oneOf([Const.FILTERS_POSITION_TOP, Const.FILTERS_POSITION_INLINE, Const.FILTERS_POSITION_BOTTOM]),
-  footerClasses: PropTypes.string,
-  defaultSorted: PropTypes.arrayOf(PropTypes.shape({
-    dataField: PropTypes.string.isRequired,
-    order: PropTypes.oneOf([Const.SORT_DESC, Const.SORT_ASC]).isRequired
+  rowStyle: _propTypes2.default.oneOfType([_propTypes2.default.object, _propTypes2.default.func]),
+  rowEvents: _propTypes2.default.object,
+  rowClasses: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.func]),
+  filtersClasses: _propTypes2.default.string,
+  filterPosition: _propTypes2.default.oneOf([_const2.default.FILTERS_POSITION_TOP, _const2.default.FILTERS_POSITION_INLINE, _const2.default.FILTERS_POSITION_BOTTOM]),
+  footerClasses: _propTypes2.default.string,
+  defaultSorted: _propTypes2.default.arrayOf(_propTypes2.default.shape({
+    dataField: _propTypes2.default.string.isRequired,
+    order: _propTypes2.default.oneOf([_const2.default.SORT_DESC, _const2.default.SORT_ASC]).isRequired
   })),
-  sort: PropTypes.shape({
-    dataField: PropTypes.string,
-    order: PropTypes.oneOf([Const.SORT_DESC, Const.SORT_ASC]),
-    sortFunc: PropTypes.func,
-    sortCaret: PropTypes.func
+  sort: _propTypes2.default.shape({
+    dataField: _propTypes2.default.string,
+    order: _propTypes2.default.oneOf([_const2.default.SORT_DESC, _const2.default.SORT_ASC]),
+    sortFunc: _propTypes2.default.func,
+    sortCaret: _propTypes2.default.func
   }),
-  defaultSortDirection: PropTypes.oneOf([Const.SORT_DESC, Const.SORT_ASC]),
-  overlay: PropTypes.func,
-  onTableChange: PropTypes.func,
-  onSort: PropTypes.func,
-  onFilter: PropTypes.func,
-  onExternalFilter: PropTypes.func,
-  onDataSizeChange: PropTypes.func,
+  defaultSortDirection: _propTypes2.default.oneOf([_const2.default.SORT_DESC, _const2.default.SORT_ASC]),
+  overlay: _propTypes2.default.func,
+  onTableChange: _propTypes2.default.func,
+  onSort: _propTypes2.default.func,
+  onFilter: _propTypes2.default.func,
+  onExternalFilter: _propTypes2.default.func,
+  onDataSizeChange: _propTypes2.default.func,
   // Inject from toolkit
-  search: PropTypes.shape({
-    searchText: PropTypes.string,
-    searchContext: PropTypes.func
+  search: _propTypes2.default.shape({
+    searchText: _propTypes2.default.string,
+    searchContext: _propTypes2.default.func
   }),
-  setDependencyModules: PropTypes.func
+  setDependencyModules: _propTypes2.default.func
 };
+
 BootstrapTable.defaultProps = {
@@ -240,3 +321,3 @@ bootstrap4: false,
   selectRow: {
-    mode: Const.ROW_SELECT_DISABLED,
+    mode: _const2.default.ROW_SELECT_DISABLED,
     selected: [],
@@ -254,4 +335,5 @@ hideSelectColumn: true
   },
-  filterPosition: Const.FILTERS_POSITION_INLINE
+  filterPosition: _const2.default.FILTERS_POSITION_INLINE
 };
-export default BootstrapTable;
+
+exports.default = BootstrapTable;

lib/src/caption.js

@@ -0,12 +1,31 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 /* eslint react/require-default-props: 0 */
-import React from 'react';
-import PropTypes from 'prop-types';
+var Caption = function Caption(props) {
+  if (!props.children) return null;
 
-const Caption = props => {
-  if (!props.children) return null;
-  const caption = props.bootstrap4 ? /*#__PURE__*/React.createElement("caption", {
-    style: {
-      captionSide: 'top'
-    }
-  }, props.children) : /*#__PURE__*/React.createElement("caption", null, props.children);
+  var caption = props.bootstrap4 ? _react2.default.createElement(
+    'caption',
+    { style: { captionSide: 'top' } },
+    props.children
+  ) : _react2.default.createElement(
+    'caption',
+    null,
+    props.children
+  );
+
   return caption;
@@ -16,5 +35,6 @@ };
 Caption.propTypes = {
-  children: PropTypes.oneOfType([PropTypes.node, PropTypes.string]),
-  bootstrap4: PropTypes.bool
+  children: _propTypes2.default.oneOfType([_propTypes2.default.node, _propTypes2.default.string]),
+  bootstrap4: _propTypes2.default.bool
 };
-export default Caption;
+
+exports.default = Caption;

lib/src/cell-event-delegater.js

@@ -1,31 +0,71 @@
-import _ from './utils';
-const events = ['onClick', 'onDoubleClick', 'onMouseEnter', 'onMouseLeave', 'onContextMenu', 'onAuxClick'];
-export default (ExtendBase => class CellEventDelegater extends ExtendBase {
-  constructor(props) {
-    super(props);
-    this.createDefaultEventHandler = this.createDefaultEventHandler.bind(this);
-  }
+'use strict';
 
-  createDefaultEventHandler(cb) {
-    return e => {
-      const {
-        column,
-        columnIndex,
-        index
-      } = this.props;
-      cb(e, column, typeof columnIndex !== 'undefined' ? columnIndex : index);
-    };
-  }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-  delegate(attrs = {}) {
-    const newAttrs = { ...attrs
-    };
-    Object.keys(attrs).forEach(attr => {
-      if (_.contains(events, attr)) {
-        newAttrs[attr] = this.createDefaultEventHandler(attrs[attr]);
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _utils = require('./utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var events = ['onClick', 'onDoubleClick', 'onMouseEnter', 'onMouseLeave', 'onContextMenu', 'onAuxClick'];
+
+exports.default = function (ExtendBase) {
+  return function (_ExtendBase) {
+    _inherits(CellEventDelegater, _ExtendBase);
+
+    function CellEventDelegater(props) {
+      _classCallCheck(this, CellEventDelegater);
+
+      var _this = _possibleConstructorReturn(this, (CellEventDelegater.__proto__ || Object.getPrototypeOf(CellEventDelegater)).call(this, props));
+
+      _this.createDefaultEventHandler = _this.createDefaultEventHandler.bind(_this);
+      return _this;
+    }
+
+    _createClass(CellEventDelegater, [{
+      key: 'createDefaultEventHandler',
+      value: function createDefaultEventHandler(cb) {
+        var _this2 = this;
+
+        return function (e) {
+          var _props = _this2.props,
+              column = _props.column,
+              columnIndex = _props.columnIndex,
+              index = _props.index;
+
+          cb(e, column, typeof columnIndex !== 'undefined' ? columnIndex : index);
+        };
       }
-    });
-    return newAttrs;
-  }
+    }, {
+      key: 'delegate',
+      value: function delegate() {
+        var _this3 = this;
 
-});
+        var attrs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+        var newAttrs = _extends({}, attrs);
+        Object.keys(attrs).forEach(function (attr) {
+          if (_utils2.default.contains(events, attr)) {
+            newAttrs[attr] = _this3.createDefaultEventHandler(attrs[attr]);
+          }
+        });
+        return newAttrs;
+      }
+    }]);
+
+    return CellEventDelegater;
+  }(ExtendBase);
+};

lib/src/cell.js

@@ -1,88 +0,134 @@
-/* eslint react/prop-types: 0 */
-import React, { Component } from 'react';
-import PropTypes from 'prop-types';
-import eventDelegater from './cell-event-delegater';
-import _ from './utils';
+'use strict';
 
-class Cell extends eventDelegater(Component) {
-  constructor(props) {
-    super(props);
-    this.createHandleEditingCell = this.createHandleEditingCell.bind(this);
-  }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-  shouldComponentUpdate(nextProps) {
-    let shouldUpdate = false;
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
 
-    if (nextProps.column.isDummyField) {
-      shouldUpdate = !_.isEqual(this.props.row, nextProps.row);
-    } else {
-      shouldUpdate = _.get(this.props.row, this.props.column.dataField) !== _.get(nextProps.row, nextProps.column.dataField);
-    }
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-    if (shouldUpdate) return true; // if (nextProps.formatter)
+var _react = require('react');
 
-    shouldUpdate = (nextProps.column.formatter ? !_.isEqual(this.props.row, nextProps.row) : false) || this.props.column.hidden !== nextProps.column.hidden || this.props.column.isDummyField !== nextProps.column.isDummyField || this.props.rowIndex !== nextProps.rowIndex || this.props.columnIndex !== nextProps.columnIndex || this.props.className !== nextProps.className || this.props.title !== nextProps.title || this.props.editable !== nextProps.editable || this.props.clickToEdit !== nextProps.clickToEdit || this.props.dbclickToEdit !== nextProps.dbclickToEdit || !_.isEqual(this.props.style, nextProps.style) || !_.isEqual(this.props.column.formatExtraData, nextProps.column.formatExtraData) || !_.isEqual(this.props.column.events, nextProps.column.events) || !_.isEqual(this.props.column.attrs, nextProps.column.attrs) || this.props.tabIndex !== nextProps.tabIndex;
-    return shouldUpdate;
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _cellEventDelegater = require('./cell-event-delegater');
+
+var _cellEventDelegater2 = _interopRequireDefault(_cellEventDelegater);
+
+var _utils = require('./utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint react/prop-types: 0 */
+
+
+var Cell = function (_eventDelegater) {
+  _inherits(Cell, _eventDelegater);
+
+  function Cell(props) {
+    _classCallCheck(this, Cell);
+
+    var _this = _possibleConstructorReturn(this, (Cell.__proto__ || Object.getPrototypeOf(Cell)).call(this, props));
+
+    _this.createHandleEditingCell = function (originFunc) {
+      return function (e) {
+        var _this$props = _this.props,
+            onStart = _this$props.onStart,
+            rowIndex = _this$props.rowIndex,
+            columnIndex = _this$props.columnIndex,
+            clickToEdit = _this$props.clickToEdit,
+            dbclickToEdit = _this$props.dbclickToEdit;
+
+        if ((clickToEdit || dbclickToEdit) && _utils2.default.isFunction(originFunc)) {
+          originFunc(e);
+        }
+        if (onStart) {
+          onStart(rowIndex, columnIndex);
+        }
+      };
+    };
+
+    _this.createHandleEditingCell = _this.createHandleEditingCell.bind(_this);
+    return _this;
   }
 
-  createHandleEditingCell = originFunc => e => {
-    const {
-      onStart,
-      rowIndex,
-      columnIndex,
-      clickToEdit,
-      dbclickToEdit
-    } = this.props;
+  _createClass(Cell, [{
+    key: 'shouldComponentUpdate',
+    value: function shouldComponentUpdate(nextProps) {
+      var shouldUpdate = false;
+      if (nextProps.column.isDummyField) {
+        shouldUpdate = !_utils2.default.isEqual(this.props.row, nextProps.row);
+      } else {
+        shouldUpdate = _utils2.default.get(this.props.row, this.props.column.dataField) !== _utils2.default.get(nextProps.row, nextProps.column.dataField);
+      }
 
-    if ((clickToEdit || dbclickToEdit) && _.isFunction(originFunc)) {
-      originFunc(e);
-    }
+      if (shouldUpdate) return true;
 
-    if (onStart) {
-      onStart(rowIndex, columnIndex);
+      // if (nextProps.formatter)
+
+      shouldUpdate = (nextProps.column.formatter ? !_utils2.default.isEqual(this.props.row, nextProps.row) : false) || this.props.column.hidden !== nextProps.column.hidden || this.props.column.isDummyField !== nextProps.column.isDummyField || this.props.rowIndex !== nextProps.rowIndex || this.props.columnIndex !== nextProps.columnIndex || this.props.className !== nextProps.className || this.props.title !== nextProps.title || this.props.editable !== nextProps.editable || this.props.clickToEdit !== nextProps.clickToEdit || this.props.dbclickToEdit !== nextProps.dbclickToEdit || !_utils2.default.isEqual(this.props.style, nextProps.style) || !_utils2.default.isEqual(this.props.column.formatExtraData, nextProps.column.formatExtraData) || !_utils2.default.isEqual(this.props.column.events, nextProps.column.events) || !_utils2.default.isEqual(this.props.column.attrs, nextProps.column.attrs) || this.props.tabIndex !== nextProps.tabIndex;
+      return shouldUpdate;
     }
-  };
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          row = _props.row,
+          rowIndex = _props.rowIndex,
+          column = _props.column,
+          columnIndex = _props.columnIndex,
+          onStart = _props.onStart,
+          editable = _props.editable,
+          clickToEdit = _props.clickToEdit,
+          dbclickToEdit = _props.dbclickToEdit,
+          rest = _objectWithoutProperties(_props, ['row', 'rowIndex', 'column', 'columnIndex', 'onStart', 'editable', 'clickToEdit', 'dbclickToEdit']);
 
-  render() {
-    const {
-      row,
-      rowIndex,
-      column,
-      columnIndex,
-      onStart,
-      editable,
-      clickToEdit,
-      dbclickToEdit,
-      ...rest
-    } = this.props;
-    const {
-      dataField,
-      formatter,
-      formatExtraData
-    } = column;
-    const attrs = this.delegate({ ...rest
-    });
-    let content = column.isDummyField ? null : _.get(row, dataField);
+      var dataField = column.dataField,
+          formatter = column.formatter,
+          formatExtraData = column.formatExtraData;
 
-    if (formatter) {
-      content = column.formatter(content, row, rowIndex, formatExtraData);
-    }
+      var attrs = this.delegate(_extends({}, rest));
+      var content = column.isDummyField ? null : _utils2.default.get(row, dataField);
 
-    if (clickToEdit && editable) {
-      attrs.onClick = this.createHandleEditingCell(attrs.onClick);
-    } else if (dbclickToEdit && editable) {
-      attrs.onDoubleClick = this.createHandleEditingCell(attrs.onDoubleClick);
+      if (formatter) {
+        content = column.formatter(content, row, rowIndex, formatExtraData);
+      }
+
+      if (clickToEdit && editable) {
+        attrs.onClick = this.createHandleEditingCell(attrs.onClick);
+      } else if (dbclickToEdit && editable) {
+        attrs.onDoubleClick = this.createHandleEditingCell(attrs.onDoubleClick);
+      }
+
+      return _react2.default.createElement(
+        'td',
+        attrs,
+        typeof content === 'boolean' ? '' + content : content
+      );
     }
+  }]);
 
-    return /*#__PURE__*/React.createElement("td", attrs, typeof content === 'boolean' ? `${content}` : content);
-  }
+  return Cell;
+}((0, _cellEventDelegater2.default)(_react.Component));
 
-}
-
 Cell.propTypes = {
-  row: PropTypes.object.isRequired,
-  rowIndex: PropTypes.number.isRequired,
-  column: PropTypes.object.isRequired,
-  columnIndex: PropTypes.number.isRequired
+  row: _propTypes2.default.object.isRequired,
+  rowIndex: _propTypes2.default.number.isRequired,
+  column: _propTypes2.default.object.isRequired,
+  columnIndex: _propTypes2.default.number.isRequired
 };
-export default Cell;
+
+exports.default = Cell;

lib/src/const.js

@@ -1,2 +0,7 @@
-export default {
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = {
   SORT_ASC: 'asc',
@@ -3,0 +8,0 @@ SORT_DESC: 'desc',

lib/src/contexts/bootstrap.js

@@ -1,4 +0,16 @@
-import React from 'react';
-export const BootstrapContext = /*#__PURE__*/React.createContext({
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BootstrapContext = undefined;
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var BootstrapContext = exports.BootstrapContext = _react2.default.createContext({
   bootstrap4: false
 });

lib/src/contexts/column-context.js

@@ -1,40 +0,76 @@
-/* eslint react/prop-types: 0 */
+'use strict';
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint react/prop-types: 0 */
 /* eslint react/prefer-stateless-function: 0 */
-import React from 'react';
-import PropTypes from 'prop-types';
-export default (() => {
-  const ColumnManagementContext = /*#__PURE__*/React.createContext();
 
-  class ColumnManagementProvider extends React.Component {
-    static propTypes = {
-      columns: PropTypes.array.isRequired,
-      toggles: PropTypes.object
-    };
-    static defaultProps = {
-      toggles: null
-    };
 
-    render() {
-      let toggleColumn;
-      const {
-        columns,
-        toggles
-      } = this.props;
+exports.default = function () {
+  var ColumnManagementContext = _react2.default.createContext();
 
-      if (toggles) {
-        toggleColumn = columns.filter(column => toggles[column.dataField]);
-      } else {
-        toggleColumn = columns.filter(column => !column.hidden);
-      }
+  var ColumnManagementProvider = function (_React$Component) {
+    _inherits(ColumnManagementProvider, _React$Component);
 
-      return /*#__PURE__*/React.createElement(ColumnManagementContext.Provider, {
-        value: {
-          columns: toggleColumn
-        }
-      }, this.props.children);
+    function ColumnManagementProvider() {
+      _classCallCheck(this, ColumnManagementProvider);
+
+      return _possibleConstructorReturn(this, (ColumnManagementProvider.__proto__ || Object.getPrototypeOf(ColumnManagementProvider)).apply(this, arguments));
     }
 
-  }
+    _createClass(ColumnManagementProvider, [{
+      key: 'render',
+      value: function render() {
+        var toggleColumn = void 0;
+        var _props = this.props,
+            columns = _props.columns,
+            toggles = _props.toggles;
 
+        if (toggles) {
+          toggleColumn = columns.filter(function (column) {
+            return toggles[column.dataField];
+          });
+        } else {
+          toggleColumn = columns.filter(function (column) {
+            return !column.hidden;
+          });
+        }
+        return _react2.default.createElement(
+          ColumnManagementContext.Provider,
+          { value: { columns: toggleColumn } },
+          this.props.children
+        );
+      }
+    }]);
+
+    return ColumnManagementProvider;
+  }(_react2.default.Component);
+
+  ColumnManagementProvider.propTypes = {
+    columns: _propTypes2.default.array.isRequired,
+    toggles: _propTypes2.default.object
+  };
+  ColumnManagementProvider.defaultProps = {
+    toggles: null
+  };
+
+
   return {
@@ -44,2 +80,2 @@ Provider: ColumnManagementProvider,
   };
-});
+};

lib/src/contexts/data-context.js

@@ -1,37 +0,80 @@
-/* eslint camelcase: 0 */
-import React, { Component } from 'react';
-import PropTypes from 'prop-types';
-export default (() => {
-  const DataContext = /*#__PURE__*/React.createContext();
+'use strict';
 
-  class DataProvider extends Component {
-    static propTypes = {
-      data: PropTypes.array.isRequired,
-      children: PropTypes.node.isRequired
-    };
-    state = {
-      data: this.props.data
-    };
-    getData = (filterProps, searchProps, sortProps, paginationProps) => {
-      if (paginationProps) return paginationProps.data;else if (sortProps) return sortProps.data;else if (searchProps) return searchProps.data;else if (filterProps) return filterProps.data;
-      return this.props.data;
-    };
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-    UNSAFE_componentWillReceiveProps(nextProps) {
-      this.setState(() => ({
-        data: nextProps.data
-      }));
-    }
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-    render() {
-      return /*#__PURE__*/React.createElement(DataContext.Provider, {
-        value: {
-          data: this.state.data,
-          getData: this.getData
-        }
-      }, this.props.children);
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint camelcase: 0 */
+
+
+exports.default = function () {
+  var DataContext = _react2.default.createContext();
+
+  var DataProvider = function (_Component) {
+    _inherits(DataProvider, _Component);
+
+    function DataProvider() {
+      var _ref;
+
+      var _temp, _this, _ret;
+
+      _classCallCheck(this, DataProvider);
+
+      for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = DataProvider.__proto__ || Object.getPrototypeOf(DataProvider)).call.apply(_ref, [this].concat(args))), _this), _this.state = { data: _this.props.data }, _this.getData = function (filterProps, searchProps, sortProps, paginationProps) {
+        if (paginationProps) return paginationProps.data;else if (sortProps) return sortProps.data;else if (searchProps) return searchProps.data;else if (filterProps) return filterProps.data;
+        return _this.props.data;
+      }, _temp), _possibleConstructorReturn(_this, _ret);
     }
 
-  }
+    _createClass(DataProvider, [{
+      key: 'UNSAFE_componentWillReceiveProps',
+      value: function UNSAFE_componentWillReceiveProps(nextProps) {
+        this.setState(function () {
+          return { data: nextProps.data };
+        });
+      }
+    }, {
+      key: 'render',
+      value: function render() {
+        return _react2.default.createElement(
+          DataContext.Provider,
+          {
+            value: {
+              data: this.state.data,
+              getData: this.getData
+            }
+          },
+          this.props.children
+        );
+      }
+    }]);
 
+    return DataProvider;
+  }(_react.Component);
+
+  DataProvider.propTypes = {
+    data: _propTypes2.default.array.isRequired,
+    children: _propTypes2.default.node.isRequired
+  };
+
   return {
@@ -41,2 +84,2 @@ Provider: DataProvider,
   };
-});
+};

lib/src/contexts/index.js

@@ -1,243 +0,434 @@
-function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+'use strict';
 
-/* eslint camelcase: 0 */
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _events = require('events');
+
+var _events2 = _interopRequireDefault(_events);
+
+var _utils = require('../utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+var _dataContext = require('./data-context');
+
+var _dataContext2 = _interopRequireDefault(_dataContext);
+
+var _columnContext = require('./column-context');
+
+var _columnContext2 = _interopRequireDefault(_columnContext);
+
+var _sortContext = require('./sort-context');
+
+var _sortContext2 = _interopRequireDefault(_sortContext);
+
+var _selectionContext = require('./selection-context');
+
+var _selectionContext2 = _interopRequireDefault(_selectionContext);
+
+var _rowExpandContext = require('./row-expand-context');
+
+var _rowExpandContext2 = _interopRequireDefault(_rowExpandContext);
+
+var _remoteResolver2 = require('../props-resolver/remote-resolver');
+
+var _remoteResolver3 = _interopRequireDefault(_remoteResolver2);
+
+var _bootstrap = require('./bootstrap');
+
+var _operators = require('../store/operators');
+
+var _operators2 = _interopRequireDefault(_operators);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint camelcase: 0 */
 /* eslint no-return-assign: 0 */
-
 /* eslint no-param-reassign: 0 */
-
 /* eslint class-methods-use-this: 0 */
-import React, { Component } from 'react';
-import EventEmitter from 'events';
-import _ from '../utils';
-import createDataContext from './data-context';
-import createColumnMgtContext from './column-context';
-import createSortContext from './sort-context';
-import SelectionContext from './selection-context';
-import RowExpandContext from './row-expand-context';
-import remoteResolver from '../props-resolver/remote-resolver';
-import { BootstrapContext } from './bootstrap';
-import dataOperator from '../store/operators';
 
-const withContext = Base => class BootstrapTableContainer extends remoteResolver(Component) {
-  constructor(props) {
-    super(props);
-    this.DataContext = createDataContext();
 
-    if (props.registerExposedAPI) {
-      const exposedAPIEmitter = new EventEmitter();
-      exposedAPIEmitter.on('get.table.data', payload => payload.result = this.table.getData());
-      exposedAPIEmitter.on('get.selected.rows', payload => payload.result = this.selectionContext.getSelected());
-      exposedAPIEmitter.on('get.filtered.rows', payload => {
-        if (this.searchContext) {
-          payload.result = this.searchContext.getSearched();
-        } else if (this.filterContext) {
-          payload.result = this.filterContext.getFiltered();
-        } else {
-          payload.result = this.table.getData();
-        }
-      });
-      props.registerExposedAPI(exposedAPIEmitter);
-    }
+var withContext = function withContext(Base) {
+  return function (_remoteResolver) {
+    _inherits(BootstrapTableContainer, _remoteResolver);
 
-    if (props.columns.filter(col => col.sort).length > 0) {
-      this.SortContext = createSortContext(dataOperator, this.isRemoteSort, this.handleRemoteSortChange);
-    }
+    function BootstrapTableContainer(props) {
+      _classCallCheck(this, BootstrapTableContainer);
 
-    if (props.columnToggle || props.columns.filter(col => col.hidden).length > 0) {
-      this.ColumnManagementContext = createColumnMgtContext();
-    }
+      var _this = _possibleConstructorReturn(this, (BootstrapTableContainer.__proto__ || Object.getPrototypeOf(BootstrapTableContainer)).call(this, props));
 
-    if (props.selectRow) {
-      this.SelectionContext = SelectionContext;
-    }
+      _this.DataContext = (0, _dataContext2.default)();
 
-    if (props.expandRow) {
-      this.RowExpandContext = RowExpandContext;
-    }
+      if (props.registerExposedAPI) {
+        var exposedAPIEmitter = new _events2.default();
+        exposedAPIEmitter.on('get.table.data', function (payload) {
+          return payload.result = _this.table.getData();
+        });
+        exposedAPIEmitter.on('get.selected.rows', function (payload) {
+          return payload.result = _this.selectionContext.getSelected();
+        });
+        exposedAPIEmitter.on('get.filtered.rows', function (payload) {
+          if (_this.searchContext) {
+            payload.result = _this.searchContext.getSearched();
+          } else if (_this.filterContext) {
+            payload.result = _this.filterContext.getFiltered();
+          } else {
+            payload.result = _this.table.getData();
+          }
+        });
+        props.registerExposedAPI(exposedAPIEmitter);
+      }
 
-    if (props.cellEdit && props.cellEdit.createContext) {
-      this.CellEditContext = props.cellEdit.createContext(_, dataOperator, this.isRemoteCellEdit, this.handleRemoteCellChange);
-    }
+      if (props.columns.filter(function (col) {
+        return col.sort;
+      }).length > 0) {
+        _this.SortContext = (0, _sortContext2.default)(_operators2.default, _this.isRemoteSort, _this.handleRemoteSortChange);
+      }
 
-    if (props.filter) {
-      this.FilterContext = props.filter.createContext(_, this.isRemoteFiltering, this.handleRemoteFilterChange);
-    }
+      if (props.columnToggle || props.columns.filter(function (col) {
+        return col.hidden;
+      }).length > 0) {
+        _this.ColumnManagementContext = (0, _columnContext2.default)();
+      }
 
-    if (props.pagination) {
-      this.PaginationContext = props.pagination.createContext();
-    }
+      if (props.selectRow) {
+        _this.SelectionContext = _selectionContext2.default;
+      }
 
-    if (props.search && props.search.searchContext) {
-      this.SearchContext = props.search.searchContext(_, this.isRemoteSearch, this.handleRemoteSearchChange);
-    }
+      if (props.expandRow) {
+        _this.RowExpandContext = _rowExpandContext2.default;
+      }
 
-    if (props.setDependencyModules) {
-      props.setDependencyModules(_);
-    }
+      if (props.cellEdit && props.cellEdit.createContext) {
+        _this.CellEditContext = props.cellEdit.createContext(_utils2.default, _operators2.default, _this.isRemoteCellEdit, _this.handleRemoteCellChange);
+      }
 
-    if (props.setPaginationRemoteEmitter) {
-      props.setPaginationRemoteEmitter(this.remoteEmitter);
-    }
-  }
+      if (props.filter) {
+        _this.FilterContext = props.filter.createContext(_utils2.default, _this.isRemoteFiltering, _this.handleRemoteFilterChange);
+      }
 
-  UNSAFE_componentWillReceiveProps(nextProps) {
-    if (nextProps.columns.filter(col => col.sort).length <= 0) {
-      this.SortContext = null;
-    } else if (!this.SortContext) {
-      this.SortContext = createSortContext(dataOperator, this.isRemoteSort, this.handleRemoteSortChange);
-    }
+      if (props.pagination) {
+        _this.PaginationContext = props.pagination.createContext();
+      }
 
-    if (!nextProps.pagination && this.props.pagination) {
-      this.PaginationContext = null;
-    }
+      if (props.search && props.search.searchContext) {
+        _this.SearchContext = props.search.searchContext(_utils2.default, _this.isRemoteSearch, _this.handleRemoteSearchChange);
+      }
 
-    if (nextProps.pagination && !this.props.pagination) {
-      this.PaginationContext = nextProps.pagination.createContext(this.isRemotePagination, this.handleRemotePageChange);
-    }
+      if (props.setDependencyModules) {
+        props.setDependencyModules(_utils2.default);
+      }
 
-    if (!nextProps.cellEdit && this.props.cellEdit) {
-      this.CellEditContext = null;
+      if (props.setPaginationRemoteEmitter) {
+        props.setPaginationRemoteEmitter(_this.remoteEmitter);
+      }
+      return _this;
     }
 
-    if (nextProps.cellEdit && !this.props.cellEdit) {
-      this.CellEditContext = nextProps.cellEdit.createContext(_, dataOperator, this.isRemoteCellEdit, this.handleRemoteCellChange);
-    }
-  }
+    _createClass(BootstrapTableContainer, [{
+      key: 'UNSAFE_componentWillReceiveProps',
+      value: function UNSAFE_componentWillReceiveProps(nextProps) {
+        if (nextProps.columns.filter(function (col) {
+          return col.sort;
+        }).length <= 0) {
+          this.SortContext = null;
+        } else if (!this.SortContext) {
+          this.SortContext = (0, _sortContext2.default)(_operators2.default, this.isRemoteSort, this.handleRemoteSortChange);
+        }
+        if (!nextProps.pagination && this.props.pagination) {
+          this.PaginationContext = null;
+        }
+        if (nextProps.pagination && !this.props.pagination) {
+          this.PaginationContext = nextProps.pagination.createContext(this.isRemotePagination, this.handleRemotePageChange);
+        }
+        if (!nextProps.cellEdit && this.props.cellEdit) {
+          this.CellEditContext = null;
+        }
+        if (nextProps.cellEdit && !this.props.cellEdit) {
+          this.CellEditContext = nextProps.cellEdit.createContext(_utils2.default, _operators2.default, this.isRemoteCellEdit, this.handleRemoteCellChange);
+        }
+      }
+    }, {
+      key: 'renderBase',
+      value: function renderBase() {
+        var _this2 = this;
 
-  renderBase() {
-    return (rootProps, filterProps, searchProps, sortProps, paginationProps, columnToggleProps) => /*#__PURE__*/React.createElement(Base, _extends({
-      ref: n => this.table = n
-    }, this.props, sortProps, filterProps, searchProps, paginationProps, columnToggleProps, {
-      data: rootProps.getData(filterProps, searchProps, sortProps, paginationProps)
-    }));
-  }
+        return function (rootProps, filterProps, searchProps, sortProps, paginationProps, columnToggleProps) {
+          return _react2.default.createElement(Base, _extends({
+            ref: function ref(n) {
+              return _this2.table = n;
+            }
+          }, _this2.props, sortProps, filterProps, searchProps, paginationProps, columnToggleProps, {
+            data: rootProps.getData(filterProps, searchProps, sortProps, paginationProps)
+          }));
+        };
+      }
+    }, {
+      key: 'renderWithColumnManagementCtx',
+      value: function renderWithColumnManagementCtx(base, baseProps) {
+        var _this3 = this;
 
-  renderWithColumnManagementCtx(base, baseProps) {
-    return (rootProps, filterProps, searchProps, sortProps, paginationProps) => /*#__PURE__*/React.createElement(this.ColumnManagementContext.Provider, _extends({}, baseProps, {
-      toggles: this.props.columnToggle ? this.props.columnToggle.toggles : null
-    }), /*#__PURE__*/React.createElement(this.ColumnManagementContext.Consumer, null, columnToggleProps => base(rootProps, filterProps, searchProps, sortProps, paginationProps, columnToggleProps)));
-  }
+        return function (rootProps, filterProps, searchProps, sortProps, paginationProps) {
+          return _react2.default.createElement(
+            _this3.ColumnManagementContext.Provider,
+            _extends({}, baseProps, {
+              toggles: _this3.props.columnToggle ? _this3.props.columnToggle.toggles : null
+            }),
+            _react2.default.createElement(
+              _this3.ColumnManagementContext.Consumer,
+              null,
+              function (columnToggleProps) {
+                return base(rootProps, filterProps, searchProps, sortProps, paginationProps, columnToggleProps);
+              }
+            )
+          );
+        };
+      }
+    }, {
+      key: 'renderWithSelectionCtx',
+      value: function renderWithSelectionCtx(base, baseProps) {
+        var _this4 = this;
 
-  renderWithSelectionCtx(base, baseProps) {
-    return (rootProps, filterProps, searchProps, sortProps, paginationProps) => /*#__PURE__*/React.createElement(this.SelectionContext.Provider, _extends({}, baseProps, {
-      ref: n => this.selectionContext = n,
-      selectRow: this.props.selectRow,
-      data: rootProps.getData(filterProps, searchProps, sortProps, paginationProps)
-    }), base(rootProps, filterProps, searchProps, sortProps, paginationProps));
-  }
+        return function (rootProps, filterProps, searchProps, sortProps, paginationProps) {
+          return _react2.default.createElement(
+            _this4.SelectionContext.Provider,
+            _extends({}, baseProps, {
+              ref: function ref(n) {
+                return _this4.selectionContext = n;
+              },
+              selectRow: _this4.props.selectRow,
+              data: rootProps.getData(filterProps, searchProps, sortProps, paginationProps)
+            }),
+            base(rootProps, filterProps, searchProps, sortProps, paginationProps)
+          );
+        };
+      }
+    }, {
+      key: 'renderWithRowExpandCtx',
+      value: function renderWithRowExpandCtx(base, baseProps) {
+        var _this5 = this;
 
-  renderWithRowExpandCtx(base, baseProps) {
-    return (rootProps, filterProps, searchProps, sortProps, paginationProps) => /*#__PURE__*/React.createElement(this.RowExpandContext.Provider, _extends({}, baseProps, {
-      ref: n => this.rowExpandContext = n,
-      expandRow: this.props.expandRow,
-      data: rootProps.getData(filterProps, searchProps, sortProps, paginationProps)
-    }), base(rootProps, filterProps, searchProps, sortProps, paginationProps));
-  }
+        return function (rootProps, filterProps, searchProps, sortProps, paginationProps) {
+          return _react2.default.createElement(
+            _this5.RowExpandContext.Provider,
+            _extends({}, baseProps, {
+              ref: function ref(n) {
+                return _this5.rowExpandContext = n;
+              },
+              expandRow: _this5.props.expandRow,
+              data: rootProps.getData(filterProps, searchProps, sortProps, paginationProps)
+            }),
+            base(rootProps, filterProps, searchProps, sortProps, paginationProps)
+          );
+        };
+      }
+    }, {
+      key: 'renderWithPaginationCtx',
+      value: function renderWithPaginationCtx(base) {
+        var _this6 = this;
 
-  renderWithPaginationCtx(base) {
-    return (rootProps, filterProps, searchProps, sortProps) => /*#__PURE__*/React.createElement(this.PaginationContext.Provider, {
-      ref: n => this.paginationContext = n,
-      pagination: this.props.pagination,
-      data: rootProps.getData(filterProps, searchProps, sortProps),
-      bootstrap4: this.props.bootstrap4,
-      isRemotePagination: this.isRemotePagination,
-      remoteEmitter: this.remoteEmitter,
-      onDataSizeChange: this.props.onDataSizeChange,
-      tableId: this.props.id
-    }, /*#__PURE__*/React.createElement(this.PaginationContext.Consumer, null, paginationProps => base(rootProps, filterProps, searchProps, sortProps, paginationProps)));
-  }
+        return function (rootProps, filterProps, searchProps, sortProps) {
+          return _react2.default.createElement(
+            _this6.PaginationContext.Provider,
+            {
+              ref: function ref(n) {
+                return _this6.paginationContext = n;
+              },
+              pagination: _this6.props.pagination,
+              data: rootProps.getData(filterProps, searchProps, sortProps),
+              bootstrap4: _this6.props.bootstrap4,
+              isRemotePagination: _this6.isRemotePagination,
+              remoteEmitter: _this6.remoteEmitter,
+              onDataSizeChange: _this6.props.onDataSizeChange,
+              tableId: _this6.props.id
+            },
+            _react2.default.createElement(
+              _this6.PaginationContext.Consumer,
+              null,
+              function (paginationProps) {
+                return base(rootProps, filterProps, searchProps, sortProps, paginationProps);
+              }
+            )
+          );
+        };
+      }
+    }, {
+      key: 'renderWithSortCtx',
+      value: function renderWithSortCtx(base, baseProps) {
+        var _this7 = this;
 
-  renderWithSortCtx(base, baseProps) {
-    return (rootProps, filterProps, searchProps) => /*#__PURE__*/React.createElement(this.SortContext.Provider, _extends({}, baseProps, {
-      ref: n => this.sortContext = n,
-      defaultSorted: this.props.defaultSorted,
-      defaultSortDirection: this.props.defaultSortDirection,
-      sort: this.props.sort,
-      data: rootProps.getData(filterProps, searchProps)
-    }), /*#__PURE__*/React.createElement(this.SortContext.Consumer, null, sortProps => base(rootProps, filterProps, searchProps, sortProps)));
-  }
+        return function (rootProps, filterProps, searchProps) {
+          return _react2.default.createElement(
+            _this7.SortContext.Provider,
+            _extends({}, baseProps, {
+              ref: function ref(n) {
+                return _this7.sortContext = n;
+              },
+              defaultSorted: _this7.props.defaultSorted,
+              defaultSortDirection: _this7.props.defaultSortDirection,
+              sort: _this7.props.sort,
+              data: rootProps.getData(filterProps, searchProps)
+            }),
+            _react2.default.createElement(
+              _this7.SortContext.Consumer,
+              null,
+              function (sortProps) {
+                return base(rootProps, filterProps, searchProps, sortProps);
+              }
+            )
+          );
+        };
+      }
+    }, {
+      key: 'renderWithSearchCtx',
+      value: function renderWithSearchCtx(base, baseProps) {
+        var _this8 = this;
 
-  renderWithSearchCtx(base, baseProps) {
-    return (rootProps, filterProps) => /*#__PURE__*/React.createElement(this.SearchContext.Provider, _extends({}, baseProps, {
-      ref: n => this.searchContext = n,
-      data: rootProps.getData(filterProps),
-      searchText: this.props.search.searchText,
-      dataChangeListener: this.props.dataChangeListener
-    }), /*#__PURE__*/React.createElement(this.SearchContext.Consumer, null, searchProps => base(rootProps, filterProps, searchProps)));
-  }
+        return function (rootProps, filterProps) {
+          return _react2.default.createElement(
+            _this8.SearchContext.Provider,
+            _extends({}, baseProps, {
+              ref: function ref(n) {
+                return _this8.searchContext = n;
+              },
+              data: rootProps.getData(filterProps),
+              searchText: _this8.props.search.searchText,
+              dataChangeListener: _this8.props.dataChangeListener
+            }),
+            _react2.default.createElement(
+              _this8.SearchContext.Consumer,
+              null,
+              function (searchProps) {
+                return base(rootProps, filterProps, searchProps);
+              }
+            )
+          );
+        };
+      }
+    }, {
+      key: 'renderWithFilterCtx',
+      value: function renderWithFilterCtx(base, baseProps) {
+        var _this9 = this;
 
-  renderWithFilterCtx(base, baseProps) {
-    return rootProps => /*#__PURE__*/React.createElement(this.FilterContext.Provider, _extends({}, baseProps, {
-      ref: n => this.filterContext = n,
-      data: rootProps.getData(),
-      filter: this.props.filter.options || {},
-      dataChangeListener: this.props.dataChangeListener
-    }), /*#__PURE__*/React.createElement(this.FilterContext.Consumer, null, filterProps => base(rootProps, filterProps)));
-  }
+        return function (rootProps) {
+          return _react2.default.createElement(
+            _this9.FilterContext.Provider,
+            _extends({}, baseProps, {
+              ref: function ref(n) {
+                return _this9.filterContext = n;
+              },
+              data: rootProps.getData(),
+              filter: _this9.props.filter.options || {},
+              dataChangeListener: _this9.props.dataChangeListener
+            }),
+            _react2.default.createElement(
+              _this9.FilterContext.Consumer,
+              null,
+              function (filterProps) {
+                return base(rootProps, filterProps);
+              }
+            )
+          );
+        };
+      }
+    }, {
+      key: 'renderWithCellEditCtx',
+      value: function renderWithCellEditCtx(base, baseProps) {
+        var _this10 = this;
 
-  renderWithCellEditCtx(base, baseProps) {
-    return rootProps => /*#__PURE__*/React.createElement(this.CellEditContext.Provider, _extends({}, baseProps, {
-      ref: n => this.cellEditContext = n,
-      selectRow: this.props.selectRow,
-      cellEdit: this.props.cellEdit,
-      data: rootProps.getData()
-    }), base(rootProps));
-  }
+        return function (rootProps) {
+          return _react2.default.createElement(
+            _this10.CellEditContext.Provider,
+            _extends({}, baseProps, {
+              ref: function ref(n) {
+                return _this10.cellEditContext = n;
+              },
+              selectRow: _this10.props.selectRow,
+              cellEdit: _this10.props.cellEdit,
+              data: rootProps.getData()
+            }),
+            base(rootProps)
+          );
+        };
+      }
+    }, {
+      key: 'render',
+      value: function render() {
+        var _props = this.props,
+            keyField = _props.keyField,
+            columns = _props.columns,
+            bootstrap4 = _props.bootstrap4;
 
-  render() {
-    const {
-      keyField,
-      columns,
-      bootstrap4
-    } = this.props;
-    const baseProps = {
-      keyField,
-      columns
-    };
-    let base = this.renderBase();
+        var baseProps = { keyField: keyField, columns: columns };
 
-    if (this.ColumnManagementContext) {
-      base = this.renderWithColumnManagementCtx(base, baseProps);
-    }
+        var base = this.renderBase();
 
-    if (this.SelectionContext) {
-      base = this.renderWithSelectionCtx(base, baseProps);
-    }
+        if (this.ColumnManagementContext) {
+          base = this.renderWithColumnManagementCtx(base, baseProps);
+        }
 
-    if (this.RowExpandContext) {
-      base = this.renderWithRowExpandCtx(base, baseProps);
-    }
+        if (this.SelectionContext) {
+          base = this.renderWithSelectionCtx(base, baseProps);
+        }
 
-    if (this.PaginationContext) {
-      base = this.renderWithPaginationCtx(base, baseProps);
-    }
+        if (this.RowExpandContext) {
+          base = this.renderWithRowExpandCtx(base, baseProps);
+        }
 
-    if (this.SortContext) {
-      base = this.renderWithSortCtx(base, baseProps);
-    }
+        if (this.PaginationContext) {
+          base = this.renderWithPaginationCtx(base, baseProps);
+        }
 
-    if (this.SearchContext) {
-      base = this.renderWithSearchCtx(base, baseProps);
-    }
+        if (this.SortContext) {
+          base = this.renderWithSortCtx(base, baseProps);
+        }
 
-    if (this.FilterContext) {
-      base = this.renderWithFilterCtx(base, baseProps);
-    }
+        if (this.SearchContext) {
+          base = this.renderWithSearchCtx(base, baseProps);
+        }
 
-    if (this.CellEditContext) {
-      base = this.renderWithCellEditCtx(base, baseProps);
-    }
+        if (this.FilterContext) {
+          base = this.renderWithFilterCtx(base, baseProps);
+        }
 
-    return /*#__PURE__*/React.createElement(BootstrapContext.Provider, {
-      value: {
-        bootstrap4
+        if (this.CellEditContext) {
+          base = this.renderWithCellEditCtx(base, baseProps);
+        }
+
+        return _react2.default.createElement(
+          _bootstrap.BootstrapContext.Provider,
+          { value: { bootstrap4: bootstrap4 } },
+          _react2.default.createElement(
+            this.DataContext.Provider,
+            _extends({}, baseProps, {
+              data: this.props.data
+            }),
+            _react2.default.createElement(
+              this.DataContext.Consumer,
+              null,
+              base
+            )
+          )
+        );
       }
-    }, /*#__PURE__*/React.createElement(this.DataContext.Provider, _extends({}, baseProps, {
-      data: this.props.data
-    }), /*#__PURE__*/React.createElement(this.DataContext.Consumer, null, base)));
-  }
+    }]);
 
+    return BootstrapTableContainer;
+  }((0, _remoteResolver3.default)(_react.Component));
 };
 
-export default withContext;
+exports.default = withContext;

lib/src/contexts/row-expand-context.js

@@ -1,141 +0,197 @@
-/* eslint camelcase: 0 */
+'use strict';
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _operators = require('../store/operators');
+
+var _operators2 = _interopRequireDefault(_operators);
+
+var _utils = require('../utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint camelcase: 0 */
 /* eslint react/prop-types: 0 */
-import React from 'react';
-import PropTypes from 'prop-types';
-import dataOperator from '../store/operators';
-import _ from '../utils';
-const RowExpandContext = /*#__PURE__*/React.createContext();
 
-class RowExpandProvider extends React.Component {
-  static propTypes = {
-    children: PropTypes.node.isRequired,
-    data: PropTypes.array.isRequired,
-    keyField: PropTypes.string.isRequired
-  };
-  state = {
-    expanded: this.props.expandRow.expanded || [],
-    isClosing: this.props.expandRow.isClosing || []
-  };
-  onClosed = closedRow => {
-    this.setState({
-      isClosing: this.state.isClosing.filter(value => value !== closedRow)
-    });
-  };
 
-  UNSAFE_componentWillReceiveProps(nextProps) {
-    if (nextProps.expandRow) {
-      let nextExpanded = [...(nextProps.expandRow.expanded || this.state.expanded)];
-      const {
-        nonExpandable = []
-      } = nextProps.expandRow;
-      nextExpanded = nextExpanded.filter(rowId => !_.contains(nonExpandable, rowId));
-      const isClosing = this.state.expanded.reduce((acc, cur) => {
-        if (!_.contains(nextExpanded, cur)) {
-          acc.push(cur);
-        }
+var RowExpandContext = _react2.default.createContext();
 
-        return acc;
-      }, []);
-      this.setState(() => ({
-        expanded: nextExpanded,
-        isClosing
-      }));
-    } else {
-      this.setState(() => ({
-        expanded: this.state.expanded
-      }));
-    }
-  }
+var RowExpandProvider = function (_React$Component) {
+  _inherits(RowExpandProvider, _React$Component);
 
-  handleRowExpand = (rowKey, expanded, rowIndex, e) => {
-    const {
-      data,
-      keyField,
-      expandRow: {
-        onExpand,
-        onlyOneExpanding,
-        nonExpandable
-      }
-    } = this.props;
+  function RowExpandProvider() {
+    var _ref;
 
-    if (nonExpandable && _.contains(nonExpandable, rowKey)) {
-      return;
-    }
+    var _temp, _this, _ret;
 
-    let currExpanded = [...this.state.expanded];
-    let isClosing = [...this.state.isClosing];
+    _classCallCheck(this, RowExpandProvider);
 
-    if (expanded) {
-      if (onlyOneExpanding) {
-        isClosing = isClosing.concat(currExpanded);
-        currExpanded = [rowKey];
-      } else currExpanded.push(rowKey);
-    } else {
-      isClosing.push(rowKey);
-      currExpanded = currExpanded.filter(value => value !== rowKey);
+    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
     }
 
-    if (onExpand) {
-      const row = dataOperator.getRowByRowId(data, keyField, rowKey);
-      onExpand(row, expanded, rowIndex, e);
-    }
+    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = RowExpandProvider.__proto__ || Object.getPrototypeOf(RowExpandProvider)).call.apply(_ref, [this].concat(args))), _this), _this.state = { expanded: _this.props.expandRow.expanded || [],
+      isClosing: _this.props.expandRow.isClosing || [] }, _this.onClosed = function (closedRow) {
+      _this.setState({ isClosing: _this.state.isClosing.filter(function (value) {
+          return value !== closedRow;
+        }) });
+    }, _this.handleRowExpand = function (rowKey, expanded, rowIndex, e) {
+      var _this$props = _this.props,
+          data = _this$props.data,
+          keyField = _this$props.keyField,
+          _this$props$expandRow = _this$props.expandRow,
+          onExpand = _this$props$expandRow.onExpand,
+          onlyOneExpanding = _this$props$expandRow.onlyOneExpanding,
+          nonExpandable = _this$props$expandRow.nonExpandable;
 
-    this.setState(() => ({
-      expanded: currExpanded,
-      isClosing
-    }));
-  };
-  handleAllRowExpand = (e, expandAll) => {
-    const {
-      data,
-      keyField,
-      expandRow: {
-        onExpandAll,
-        nonExpandable
+      if (nonExpandable && _utils2.default.contains(nonExpandable, rowKey)) {
+        return;
       }
-    } = this.props;
-    const {
-      expanded
-    } = this.state;
-    let currExpanded;
 
-    if (expandAll) {
-      currExpanded = expanded.concat(dataOperator.expandableKeys(data, keyField, nonExpandable));
-    } else {
-      currExpanded = expanded.filter(s => typeof data.find(d => _.get(d, keyField) === s) === 'undefined');
-    }
+      var currExpanded = [].concat(_toConsumableArray(_this.state.expanded));
+      var isClosing = [].concat(_toConsumableArray(_this.state.isClosing));
 
-    if (onExpandAll) {
-      onExpandAll(expandAll, dataOperator.getExpandedRows(data, keyField, currExpanded), e);
-    }
+      if (expanded) {
+        if (onlyOneExpanding) {
+          isClosing = isClosing.concat(currExpanded);
+          currExpanded = [rowKey];
+        } else currExpanded.push(rowKey);
+      } else {
+        isClosing.push(rowKey);
+        currExpanded = currExpanded.filter(function (value) {
+          return value !== rowKey;
+        });
+      }
 
-    this.setState(() => ({
-      expanded: currExpanded
-    }));
-  };
+      if (onExpand) {
+        var row = _operators2.default.getRowByRowId(data, keyField, rowKey);
+        onExpand(row, expanded, rowIndex, e);
+      }
+      _this.setState(function () {
+        return { expanded: currExpanded, isClosing: isClosing };
+      });
+    }, _this.handleAllRowExpand = function (e, expandAll) {
+      var _this$props2 = _this.props,
+          data = _this$props2.data,
+          keyField = _this$props2.keyField,
+          _this$props2$expandRo = _this$props2.expandRow,
+          onExpandAll = _this$props2$expandRo.onExpandAll,
+          nonExpandable = _this$props2$expandRo.nonExpandable;
+      var expanded = _this.state.expanded;
 
-  render() {
-    const {
-      data,
-      keyField
-    } = this.props;
-    return /*#__PURE__*/React.createElement(RowExpandContext.Provider, {
-      value: { ...this.props.expandRow,
-        nonExpandable: this.props.expandRow.nonExpandable,
-        expanded: this.state.expanded,
-        isClosing: this.state.isClosing,
-        onClosed: this.onClosed,
-        isAnyExpands: dataOperator.isAnyExpands(data, keyField, this.state.expanded),
-        onRowExpand: this.handleRowExpand,
-        onAllRowExpand: this.handleAllRowExpand
+
+      var currExpanded = void 0;
+
+      if (expandAll) {
+        currExpanded = expanded.concat(_operators2.default.expandableKeys(data, keyField, nonExpandable));
+      } else {
+        currExpanded = expanded.filter(function (s) {
+          return typeof data.find(function (d) {
+            return _utils2.default.get(d, keyField) === s;
+          }) === 'undefined';
+        });
       }
-    }, this.props.children);
+
+      if (onExpandAll) {
+        onExpandAll(expandAll, _operators2.default.getExpandedRows(data, keyField, currExpanded), e);
+      }
+
+      _this.setState(function () {
+        return { expanded: currExpanded };
+      });
+    }, _temp), _possibleConstructorReturn(_this, _ret);
   }
 
-}
+  _createClass(RowExpandProvider, [{
+    key: 'UNSAFE_componentWillReceiveProps',
+    value: function UNSAFE_componentWillReceiveProps(nextProps) {
+      var _this2 = this;
 
-export default {
+      if (nextProps.expandRow) {
+        var nextExpanded = [].concat(_toConsumableArray(nextProps.expandRow.expanded || this.state.expanded));
+        var _nextProps$expandRow$ = nextProps.expandRow.nonExpandable,
+            nonExpandable = _nextProps$expandRow$ === undefined ? [] : _nextProps$expandRow$;
+
+        nextExpanded = nextExpanded.filter(function (rowId) {
+          return !_utils2.default.contains(nonExpandable, rowId);
+        });
+        var isClosing = this.state.expanded.reduce(function (acc, cur) {
+          if (!_utils2.default.contains(nextExpanded, cur)) {
+            acc.push(cur);
+          }
+          return acc;
+        }, []);
+
+        this.setState(function () {
+          return {
+            expanded: nextExpanded,
+            isClosing: isClosing
+          };
+        });
+      } else {
+        this.setState(function () {
+          return {
+            expanded: _this2.state.expanded
+          };
+        });
+      }
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          data = _props.data,
+          keyField = _props.keyField;
+
+      return _react2.default.createElement(
+        RowExpandContext.Provider,
+        {
+          value: _extends({}, this.props.expandRow, {
+            nonExpandable: this.props.expandRow.nonExpandable,
+            expanded: this.state.expanded,
+            isClosing: this.state.isClosing,
+            onClosed: this.onClosed,
+            isAnyExpands: _operators2.default.isAnyExpands(data, keyField, this.state.expanded),
+            onRowExpand: this.handleRowExpand,
+            onAllRowExpand: this.handleAllRowExpand
+          })
+        },
+        this.props.children
+      );
+    }
+  }]);
+
+  return RowExpandProvider;
+}(_react2.default.Component);
+
+RowExpandProvider.propTypes = {
+  children: _propTypes2.default.node.isRequired,
+  data: _propTypes2.default.array.isRequired,
+  keyField: _propTypes2.default.string.isRequired
+};
+exports.default = {
   Provider: RowExpandProvider,
   Consumer: RowExpandContext.Consumer
 };

lib/src/contexts/selection-context.js

@@ -1,129 +0,182 @@
-/* eslint camelcase: 0 */
+'use strict';
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _const = require('../const');
+
+var _const2 = _interopRequireDefault(_const);
+
+var _utils = require('../utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+var _operators = require('../store/operators');
+
+var _operators2 = _interopRequireDefault(_operators);
+
+var _selection = require('../store/selection');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint camelcase: 0 */
 /* eslint react/prop-types: 0 */
-import React from 'react';
-import PropTypes from 'prop-types';
-import Const from '../const';
-import _ from '../utils';
-import dataOperator from '../store/operators';
-import { getSelectionSummary } from '../store/selection';
-const SelectionContext = /*#__PURE__*/React.createContext();
 
-class SelectionProvider extends React.Component {
-  static propTypes = {
-    children: PropTypes.node.isRequired,
-    data: PropTypes.array.isRequired,
-    keyField: PropTypes.string.isRequired
-  };
 
-  constructor(props) {
-    super(props);
-    this.selected = props.selectRow.selected || [];
-  } // exposed API
+var SelectionContext = _react2.default.createContext();
 
+var SelectionProvider = function (_React$Component) {
+  _inherits(SelectionProvider, _React$Component);
 
-  getSelected() {
-    return this.selected;
-  }
+  function SelectionProvider(props) {
+    _classCallCheck(this, SelectionProvider);
 
-  UNSAFE_componentWillReceiveProps(nextProps) {
-    if (nextProps.selectRow) {
-      this.selected = nextProps.selectRow.selected || this.selected;
-    }
-  }
+    var _this = _possibleConstructorReturn(this, (SelectionProvider.__proto__ || Object.getPrototypeOf(SelectionProvider)).call(this, props));
 
-  handleRowSelect = (rowKey, checked, rowIndex, e) => {
-    const {
-      data,
-      keyField,
-      selectRow: {
-        mode,
-        onSelect
+    _this.handleRowSelect = function (rowKey, checked, rowIndex, e) {
+      var _this$props = _this.props,
+          data = _this$props.data,
+          keyField = _this$props.keyField,
+          _this$props$selectRow = _this$props.selectRow,
+          mode = _this$props$selectRow.mode,
+          onSelect = _this$props$selectRow.onSelect;
+      var ROW_SELECT_SINGLE = _const2.default.ROW_SELECT_SINGLE;
+
+
+      var currSelected = [].concat(_toConsumableArray(_this.selected));
+
+      var result = true;
+      if (onSelect) {
+        var row = _operators2.default.getRowByRowId(data, keyField, rowKey);
+        result = onSelect(row, checked, rowIndex, e);
       }
-    } = this.props;
-    const {
-      ROW_SELECT_SINGLE
-    } = Const;
-    let currSelected = [...this.selected];
-    let result = true;
 
-    if (onSelect) {
-      const row = dataOperator.getRowByRowId(data, keyField, rowKey);
-      result = onSelect(row, checked, rowIndex, e);
-    }
+      if (result === true || result === undefined) {
+        if (mode === ROW_SELECT_SINGLE) {
+          // when select mode is radio
+          currSelected = [rowKey];
+        } else if (checked) {
+          // when select mode is checkbox
+          currSelected.push(rowKey);
+        } else {
+          currSelected = currSelected.filter(function (value) {
+            return value !== rowKey;
+          });
+        }
+      }
+      _this.selected = currSelected;
+      _this.forceUpdate();
+    };
 
-    if (result === true || result === undefined) {
-      if (mode === ROW_SELECT_SINGLE) {
-        // when select mode is radio
-        currSelected = [rowKey];
-      } else if (checked) {
-        // when select mode is checkbox
-        currSelected.push(rowKey);
+    _this.handleAllRowsSelect = function (e, isUnSelect) {
+      var _this$props2 = _this.props,
+          data = _this$props2.data,
+          keyField = _this$props2.keyField,
+          _this$props2$selectRo = _this$props2.selectRow,
+          onSelectAll = _this$props2$selectRo.onSelectAll,
+          nonSelectable = _this$props2$selectRo.nonSelectable;
+      var selected = _this.selected;
+
+
+      var currSelected = void 0;
+
+      if (!isUnSelect) {
+        currSelected = selected.concat(_operators2.default.selectableKeys(data, keyField, nonSelectable));
       } else {
-        currSelected = currSelected.filter(value => value !== rowKey);
+        currSelected = selected.filter(function (s) {
+          return typeof data.find(function (d) {
+            return _utils2.default.get(d, keyField) === s;
+          }) === 'undefined';
+        });
       }
-    }
 
-    this.selected = currSelected;
-    this.forceUpdate();
-  };
-  handleAllRowsSelect = (e, isUnSelect) => {
-    const {
-      data,
-      keyField,
-      selectRow: {
-        onSelectAll,
-        nonSelectable
+      var result = void 0;
+      if (onSelectAll) {
+        result = onSelectAll(!isUnSelect, _operators2.default.getSelectedRows(data, keyField, isUnSelect ? selected : currSelected), e);
+        if (Array.isArray(result)) {
+          currSelected = result;
+        }
       }
-    } = this.props;
-    const {
-      selected
-    } = this;
-    let currSelected;
+      _this.selected = currSelected;
+      _this.forceUpdate();
+    };
 
-    if (!isUnSelect) {
-      currSelected = selected.concat(dataOperator.selectableKeys(data, keyField, nonSelectable));
-    } else {
-      currSelected = selected.filter(s => typeof data.find(d => _.get(d, keyField) === s) === 'undefined');
-    }
+    _this.selected = props.selectRow.selected || [];
+    return _this;
+  }
 
-    let result;
+  // exposed API
 
-    if (onSelectAll) {
-      result = onSelectAll(!isUnSelect, dataOperator.getSelectedRows(data, keyField, isUnSelect ? selected : currSelected), e);
 
-      if (Array.isArray(result)) {
-        currSelected = result;
+  _createClass(SelectionProvider, [{
+    key: 'getSelected',
+    value: function getSelected() {
+      return this.selected;
+    }
+  }, {
+    key: 'UNSAFE_componentWillReceiveProps',
+    value: function UNSAFE_componentWillReceiveProps(nextProps) {
+      if (nextProps.selectRow) {
+        this.selected = nextProps.selectRow.selected || this.selected;
       }
     }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _getSelectionSummary = (0, _selection.getSelectionSummary)(this.props.data, this.props.keyField, this.selected),
+          allRowsSelected = _getSelectionSummary.allRowsSelected,
+          allRowsNotSelected = _getSelectionSummary.allRowsNotSelected;
 
-    this.selected = currSelected;
-    this.forceUpdate();
-  };
+      var checkedStatus = void 0;
 
-  render() {
-    const {
-      allRowsSelected,
-      allRowsNotSelected
-    } = getSelectionSummary(this.props.data, this.props.keyField, this.selected);
-    let checkedStatus; // checkbox status depending on selected rows counts
+      // checkbox status depending on selected rows counts
+      if (allRowsSelected) checkedStatus = _const2.default.CHECKBOX_STATUS_CHECKED;else if (allRowsNotSelected) checkedStatus = _const2.default.CHECKBOX_STATUS_UNCHECKED;else checkedStatus = _const2.default.CHECKBOX_STATUS_INDETERMINATE;
 
-    if (allRowsSelected) checkedStatus = Const.CHECKBOX_STATUS_CHECKED;else if (allRowsNotSelected) checkedStatus = Const.CHECKBOX_STATUS_UNCHECKED;else checkedStatus = Const.CHECKBOX_STATUS_INDETERMINATE;
-    return /*#__PURE__*/React.createElement(SelectionContext.Provider, {
-      value: { ...this.props.selectRow,
-        selected: this.selected,
-        onRowSelect: this.handleRowSelect,
-        onAllRowsSelect: this.handleAllRowsSelect,
-        allRowsSelected,
-        allRowsNotSelected,
-        checkedStatus
-      }
-    }, this.props.children);
-  }
+      return _react2.default.createElement(
+        SelectionContext.Provider,
+        {
+          value: _extends({}, this.props.selectRow, {
+            selected: this.selected,
+            onRowSelect: this.handleRowSelect,
+            onAllRowsSelect: this.handleAllRowsSelect,
+            allRowsSelected: allRowsSelected,
+            allRowsNotSelected: allRowsNotSelected,
+            checkedStatus: checkedStatus
+          })
+        },
+        this.props.children
+      );
+    }
+  }]);
 
-}
+  return SelectionProvider;
+}(_react2.default.Component);
 
-export default {
+SelectionProvider.propTypes = {
+  children: _propTypes2.default.node.isRequired,
+  data: _propTypes2.default.array.isRequired,
+  keyField: _propTypes2.default.string.isRequired
+};
+exports.default = {
   Provider: SelectionProvider,
   Consumer: SelectionContext.Consumer
 };

lib/src/contexts/sort-context.js

@@ -1,97 +0,162 @@
-/* eslint camelcase: 0 */
+'use strict';
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _const = require('../const');
+
+var _const2 = _interopRequireDefault(_const);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint camelcase: 0 */
 /* eslint react/require-default-props: 0 */
-import React from 'react';
-import PropTypes from 'prop-types';
-import Const from '../const';
-export default ((dataOperator, isRemoteSort, handleSortChange) => {
-  const SortContext = /*#__PURE__*/React.createContext();
 
-  class SortProvider extends React.Component {
-    static propTypes = {
-      data: PropTypes.array.isRequired,
-      columns: PropTypes.array.isRequired,
-      children: PropTypes.node.isRequired,
-      defaultSorted: PropTypes.arrayOf(PropTypes.shape({
-        dataField: PropTypes.string.isRequired,
-        order: PropTypes.oneOf([Const.SORT_DESC, Const.SORT_ASC]).isRequired
-      })),
-      sort: PropTypes.shape({
-        dataField: PropTypes.string,
-        order: PropTypes.oneOf([Const.SORT_DESC, Const.SORT_ASC]),
-        sortFunc: PropTypes.func
-      }),
-      defaultSortDirection: PropTypes.oneOf([Const.SORT_DESC, Const.SORT_ASC])
-    };
 
-    constructor(props) {
-      super(props);
-      let sortOrder;
-      let sortColumn;
-      const {
-        defaultSorted,
-        defaultSortDirection,
-        sort
-      } = props;
+exports.default = function (dataOperator, isRemoteSort, handleSortChange) {
+  var SortContext = _react2.default.createContext();
 
+  var SortProvider = function (_React$Component) {
+    _inherits(SortProvider, _React$Component);
+
+    function SortProvider(props) {
+      _classCallCheck(this, SortProvider);
+
+      var _this = _possibleConstructorReturn(this, (SortProvider.__proto__ || Object.getPrototypeOf(SortProvider)).call(this, props));
+
+      _initialiseProps.call(_this);
+
+      var sortOrder = void 0;
+      var sortColumn = void 0;
+      var defaultSorted = props.defaultSorted,
+          defaultSortDirection = props.defaultSortDirection,
+          sort = props.sort;
+
+
       if (defaultSorted && defaultSorted.length > 0) {
         sortOrder = defaultSorted[0].order || defaultSortDirection;
-        sortColumn = this.initSort(defaultSorted[0].dataField, sortOrder);
+        sortColumn = _this.initSort(defaultSorted[0].dataField, sortOrder);
       } else if (sort && sort.dataField && sort.order) {
         sortOrder = sort.order;
-        sortColumn = this.initSort(sort.dataField, sortOrder);
+        sortColumn = _this.initSort(sort.dataField, sortOrder);
       }
-
-      this.state = {
-        sortOrder,
-        sortColumn
-      };
+      _this.state = { sortOrder: sortOrder, sortColumn: sortColumn };
+      return _this;
     }
 
-    componentDidMount() {
-      const {
-        sortOrder,
-        sortColumn
-      } = this.state;
+    _createClass(SortProvider, [{
+      key: 'componentDidMount',
+      value: function componentDidMount() {
+        var _state = this.state,
+            sortOrder = _state.sortOrder,
+            sortColumn = _state.sortColumn;
 
-      if (isRemoteSort() && sortOrder && sortColumn) {
-        handleSortChange(sortColumn.dataField, sortOrder);
+        if (isRemoteSort() && sortOrder && sortColumn) {
+          handleSortChange(sortColumn.dataField, sortOrder);
+        }
       }
-    }
+    }, {
+      key: 'UNSAFE_componentWillReceiveProps',
+      value: function UNSAFE_componentWillReceiveProps(nextProps) {
+        var sort = nextProps.sort,
+            columns = nextProps.columns;
 
-    UNSAFE_componentWillReceiveProps(nextProps) {
-      const {
-        sort,
-        columns
-      } = nextProps;
+        if (sort && sort.dataField && sort.order) {
+          this.setState({
+            sortOrder: sort.order,
+            sortColumn: columns.find(function (col) {
+              return col.dataField === sort.dataField;
+            })
+          });
+        }
+      }
+    }, {
+      key: 'initSort',
+      value: function initSort(sortField, sortOrder) {
+        var sortColumn = void 0;
+        var columns = this.props.columns;
 
-      if (sort && sort.dataField && sort.order) {
-        this.setState({
-          sortOrder: sort.order,
-          sortColumn: columns.find(col => col.dataField === sort.dataField)
+        var sortColumns = columns.filter(function (col) {
+          return col.dataField === sortField;
         });
+        if (sortColumns.length > 0) {
+          sortColumn = sortColumns[0];
+
+          if (sortColumn.onSort) {
+            sortColumn.onSort(sortField, sortOrder);
+          }
+        }
+        return sortColumn;
       }
-    }
+    }, {
+      key: 'render',
+      value: function render() {
+        var data = this.props.data;
+        var sort = this.props.sort;
+        var _state2 = this.state,
+            sortOrder = _state2.sortOrder,
+            sortColumn = _state2.sortColumn;
 
-    initSort(sortField, sortOrder) {
-      let sortColumn;
-      const {
-        columns
-      } = this.props;
-      const sortColumns = columns.filter(col => col.dataField === sortField);
+        if (!isRemoteSort() && sortColumn) {
+          var sortFunc = sortColumn.sortFunc ? sortColumn.sortFunc : sort && sort.sortFunc;
+          data = dataOperator.sort(data, sortOrder, _extends({}, sortColumn, { sortFunc: sortFunc }));
+        }
 
-      if (sortColumns.length > 0) {
-        sortColumn = sortColumns[0];
-
-        if (sortColumn.onSort) {
-          sortColumn.onSort(sortField, sortOrder);
-        }
+        return _react2.default.createElement(
+          SortContext.Provider,
+          {
+            value: {
+              data: data,
+              sortOrder: sortOrder,
+              onSort: this.handleSort,
+              sortField: sortColumn ? sortColumn.dataField : null
+            }
+          },
+          this.props.children
+        );
       }
+    }]);
 
-      return sortColumn;
-    }
+    return SortProvider;
+  }(_react2.default.Component);
 
-    handleSort = column => {
-      const sortOrder = dataOperator.nextOrder(column, this.state, this.props.defaultSortDirection);
+  SortProvider.propTypes = {
+    data: _propTypes2.default.array.isRequired,
+    columns: _propTypes2.default.array.isRequired,
+    children: _propTypes2.default.node.isRequired,
+    defaultSorted: _propTypes2.default.arrayOf(_propTypes2.default.shape({
+      dataField: _propTypes2.default.string.isRequired,
+      order: _propTypes2.default.oneOf([_const2.default.SORT_DESC, _const2.default.SORT_ASC]).isRequired
+    })),
+    sort: _propTypes2.default.shape({
+      dataField: _propTypes2.default.string,
+      order: _propTypes2.default.oneOf([_const2.default.SORT_DESC, _const2.default.SORT_ASC]),
+      sortFunc: _propTypes2.default.func
+    }),
+    defaultSortDirection: _propTypes2.default.oneOf([_const2.default.SORT_DESC, _const2.default.SORT_ASC])
+  };
 
+  var _initialiseProps = function _initialiseProps() {
+    var _this2 = this;
+
+    this.handleSort = function (column) {
+      var sortOrder = dataOperator.nextOrder(column, _this2.state, _this2.props.defaultSortDirection);
+
       if (column.onSort) {
@@ -104,40 +169,11 @@ column.onSort(column.dataField, sortOrder);
       }
-
-      this.setState(() => ({
-        sortOrder,
-        sortColumn: column
-      }));
+      _this2.setState(function () {
+        return {
+          sortOrder: sortOrder,
+          sortColumn: column
+        };
+      });
     };
+  };
 
-    render() {
-      let {
-        data
-      } = this.props;
-      const {
-        sort
-      } = this.props;
-      const {
-        sortOrder,
-        sortColumn
-      } = this.state;
-
-      if (!isRemoteSort() && sortColumn) {
-        const sortFunc = sortColumn.sortFunc ? sortColumn.sortFunc : sort && sort.sortFunc;
-        data = dataOperator.sort(data, sortOrder, { ...sortColumn,
-          sortFunc
-        });
-      }
-
-      return /*#__PURE__*/React.createElement(SortContext.Provider, {
-        value: {
-          data,
-          sortOrder,
-          onSort: this.handleSort,
-          sortField: sortColumn ? sortColumn.dataField : null
-        }
-      }, this.props.children);
-    }
-
-  }
-
   return {
@@ -147,2 +183,2 @@ Provider: SortProvider,
   };
-});
+};

lib/src/filters-cell.js

@@ -1,33 +0,44 @@
-function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+'use strict';
 
-import React from 'react';
-import PropTypes from 'prop-types';
-import _ from './utils';
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-const FiltersCell = props => {
-  const {
-    index,
-    column,
-    onExternalFilter,
-    currFilters,
-    onFilter
-  } = props;
-  const {
-    filterRenderer,
-    filter
-  } = column;
-  let filterElm;
-  const cellAttrs = {};
-  const cellStyle = {};
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _utils = require('./utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var FiltersCell = function FiltersCell(props) {
+  var index = props.index,
+      column = props.column,
+      onExternalFilter = props.onExternalFilter,
+      currFilters = props.currFilters,
+      onFilter = props.onFilter;
+  var filterRenderer = column.filterRenderer,
+      filter = column.filter;
+
+  var filterElm = void 0;
+  var cellAttrs = {};
+  var cellStyle = {};
   cellAttrs.style = cellStyle;
-
   if (column.headerAlign) {
-    cellStyle.textAlign = _.isFunction(column.headerAlign) ? column.headerAlign(column, index) : column.headerAlign;
+    cellStyle.textAlign = _utils2.default.isFunction(column.headerAlign) ? column.headerAlign(column, index) : column.headerAlign;
   }
-
   if (column.filterRenderer) {
-    const onCustomFilter = onExternalFilter(column, filter.props.type);
+    var onCustomFilter = onExternalFilter(column, filter.props.type);
     filterElm = filterRenderer(onCustomFilter, column);
   } else if (filter) {
-    filterElm = /*#__PURE__*/React.createElement(filter.Filter, _extends({}, filter.props, {
+    filterElm = _react2.default.createElement(filter.Filter, _extends({}, filter.props, {
       filterState: currFilters[column.dataField],
@@ -38,17 +49,18 @@ onFilter: onFilter,
   }
-
-  return /*#__PURE__*/React.createElement('th', cellAttrs, filterElm);
+  return _react2.default.createElement('th', cellAttrs, filterElm);
 };
 
 FiltersCell.propTypes = {
-  index: PropTypes.number.isRequired,
-  column: PropTypes.object.isRequired,
-  currFilters: PropTypes.object.isRequired,
-  onFilter: PropTypes.func,
-  onExternalFilter: PropTypes.func
+  index: _propTypes2.default.number.isRequired,
+  column: _propTypes2.default.object.isRequired,
+  currFilters: _propTypes2.default.object.isRequired,
+  onFilter: _propTypes2.default.func,
+  onExternalFilter: _propTypes2.default.func
 };
+
 FiltersCell.defaultProps = {
-  onFilter: () => {},
-  onExternalFilter: () => {}
+  onFilter: function onFilter() {},
+  onExternalFilter: function onExternalFilter() {}
 };
-export default FiltersCell;
+
+exports.default = FiltersCell;

lib/src/filters.js

@@ -1,25 +0,46 @@
-/* eslint react/require-default-props: 0 */
-import React from 'react';
-import PropTypes from 'prop-types';
-import FiltersCell from './filters-cell';
-import Const from './const';
-import RowTemplate from './row/row-template';
+'use strict';
 
-const Filters = props => {
-  const {
-    columns,
-    onFilter,
-    currFilters,
-    filterPosition,
-    onExternalFilter,
-    className,
-    selectRow,
-    expandRow
-  } = props;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _filtersCell = require('./filters-cell');
+
+var _filtersCell2 = _interopRequireDefault(_filtersCell);
+
+var _const = require('./const');
+
+var _const2 = _interopRequireDefault(_const);
+
+var _rowTemplate = require('./row/row-template');
+
+var _rowTemplate2 = _interopRequireDefault(_rowTemplate);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var Filters = function Filters(props) {
+  var columns = props.columns,
+      onFilter = props.onFilter,
+      currFilters = props.currFilters,
+      filterPosition = props.filterPosition,
+      onExternalFilter = props.onExternalFilter,
+      className = props.className,
+      selectRow = props.selectRow,
+      expandRow = props.expandRow;
+
+
   function renderContent() {
-    const filterColumns = [];
-    let showFiltersRow = false;
-    columns.forEach((column, i) => {
-      filterColumns.push( /*#__PURE__*/React.createElement(FiltersCell, {
+    var filterColumns = [];
+    var showFiltersRow = false;
+
+    columns.forEach(function (column, i) {
+      filterColumns.push(_react2.default.createElement(_filtersCell2.default, {
         index: i,
@@ -42,28 +63,35 @@ key: column.dataField,
 
-  return /*#__PURE__*/React.createElement("tbody", {
-    className: className,
-    style: {
-      display: filterPosition === Const.FILTERS_POSITION_TOP ? 'table-header-group' : 'table-footer-group'
-    }
-  }, /*#__PURE__*/React.createElement(RowTemplate, {
-    renderContent: renderContent,
-    selectRow: selectRow,
-    expandRow: expandRow,
-    cellEl: "td"
-  }));
-};
+  return _react2.default.createElement(
+    'tbody',
+    {
+      className: className,
+      style: {
+        display: filterPosition === _const2.default.FILTERS_POSITION_TOP ? 'table-header-group' : 'table-footer-group'
+      }
+    },
+    _react2.default.createElement(_rowTemplate2.default, {
+      renderContent: renderContent,
+      selectRow: selectRow,
+      expandRow: expandRow,
+      cellEl: 'td'
+    })
+  );
+}; /* eslint react/require-default-props: 0 */
 
+
 Filters.propTypes = {
-  columns: PropTypes.array.isRequired,
-  onFilter: PropTypes.func,
-  filterPosition: PropTypes.oneOf([Const.FILTERS_POSITION_TOP, Const.FILTERS_POSITION_INLINE, Const.FILTERS_POSITION_BOTTOM]),
-  currFilters: PropTypes.object,
-  onExternalFilter: PropTypes.func,
-  className: PropTypes.string,
-  selectRow: PropTypes.object,
-  expandRow: PropTypes.object
+  columns: _propTypes2.default.array.isRequired,
+  onFilter: _propTypes2.default.func,
+  filterPosition: _propTypes2.default.oneOf([_const2.default.FILTERS_POSITION_TOP, _const2.default.FILTERS_POSITION_INLINE, _const2.default.FILTERS_POSITION_BOTTOM]),
+  currFilters: _propTypes2.default.object,
+  onExternalFilter: _propTypes2.default.func,
+  className: _propTypes2.default.string,
+  selectRow: _propTypes2.default.object,
+  expandRow: _propTypes2.default.object
 };
+
 Filters.defaultProps = {
-  position: Const.FILTERS_POSITION_TOP
+  position: _const2.default.FILTERS_POSITION_TOP
 };
-export default Filters;
+
+exports.default = Filters;

lib/src/footer-cell.js

@@ -1,69 +0,110 @@
-/* eslint react/require-default-props: 0 */
-import React from 'react';
-import cs from 'classnames';
-import PropTypes from 'prop-types';
-import _ from './utils';
-import eventDelegater from './cell-event-delegater';
+'use strict';
 
-class FooterCell extends eventDelegater(React.Component) {
-  render() {
-    const {
-      index,
-      column,
-      columnData
-    } = this.props;
-    const {
-      footer,
-      footerTitle,
-      footerAlign,
-      footerFormatter,
-      footerEvents,
-      footerClasses,
-      footerStyle,
-      footerAttrs
-    } = column;
-    const delegateEvents = this.delegate(footerEvents);
-    const cellAttrs = { ...(_.isFunction(footerAttrs) ? footerAttrs(column, index) : footerAttrs),
-      ...delegateEvents
-    };
-    let text = '';
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-    if (_.isString(footer)) {
-      text = footer;
-    } else if (_.isFunction(footer)) {
-      text = footer(columnData, column, index);
-    }
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
 
-    let cellStyle = {};
-    const cellClasses = _.isFunction(footerClasses) ? footerClasses(column, index) : footerClasses;
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-    if (footerStyle) {
-      cellStyle = _.isFunction(footerStyle) ? footerStyle(column, index) : footerStyle;
-      cellStyle = cellStyle ? { ...cellStyle
-      } : cellStyle;
-    }
+var _react = require('react');
 
-    if (footerTitle) {
-      cellAttrs.title = _.isFunction(footerTitle) ? footerTitle(column, index) : text;
-    }
+var _react2 = _interopRequireDefault(_react);
 
-    if (footerAlign) {
-      cellStyle.textAlign = _.isFunction(footerAlign) ? footerAlign(column, index) : footerAlign;
-    }
+var _classnames = require('classnames');
 
-    if (cellClasses) cellAttrs.className = cs(cellAttrs.className, cellClasses);
-    if (!_.isEmptyObject(cellStyle)) cellAttrs.style = cellStyle;
-    const children = footerFormatter ? footerFormatter(column, index, {
-      text
-    }) : text;
-    return /*#__PURE__*/React.createElement('th', cellAttrs, children);
+var _classnames2 = _interopRequireDefault(_classnames);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _utils = require('./utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+var _cellEventDelegater = require('./cell-event-delegater');
+
+var _cellEventDelegater2 = _interopRequireDefault(_cellEventDelegater);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint react/require-default-props: 0 */
+
+
+var FooterCell = function (_eventDelegater) {
+  _inherits(FooterCell, _eventDelegater);
+
+  function FooterCell() {
+    _classCallCheck(this, FooterCell);
+
+    return _possibleConstructorReturn(this, (FooterCell.__proto__ || Object.getPrototypeOf(FooterCell)).apply(this, arguments));
   }
 
-}
+  _createClass(FooterCell, [{
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          index = _props.index,
+          column = _props.column,
+          columnData = _props.columnData;
+      var footer = column.footer,
+          footerTitle = column.footerTitle,
+          footerAlign = column.footerAlign,
+          footerFormatter = column.footerFormatter,
+          footerEvents = column.footerEvents,
+          footerClasses = column.footerClasses,
+          footerStyle = column.footerStyle,
+          footerAttrs = column.footerAttrs;
 
+
+      var delegateEvents = this.delegate(footerEvents);
+      var cellAttrs = _extends({}, _utils2.default.isFunction(footerAttrs) ? footerAttrs(column, index) : footerAttrs, delegateEvents);
+
+      var text = '';
+      if (_utils2.default.isString(footer)) {
+        text = footer;
+      } else if (_utils2.default.isFunction(footer)) {
+        text = footer(columnData, column, index);
+      }
+
+      var cellStyle = {};
+      var cellClasses = _utils2.default.isFunction(footerClasses) ? footerClasses(column, index) : footerClasses;
+
+      if (footerStyle) {
+        cellStyle = _utils2.default.isFunction(footerStyle) ? footerStyle(column, index) : footerStyle;
+        cellStyle = cellStyle ? _extends({}, cellStyle) : cellStyle;
+      }
+
+      if (footerTitle) {
+        cellAttrs.title = _utils2.default.isFunction(footerTitle) ? footerTitle(column, index) : text;
+      }
+
+      if (footerAlign) {
+        cellStyle.textAlign = _utils2.default.isFunction(footerAlign) ? footerAlign(column, index) : footerAlign;
+      }
+
+      if (cellClasses) cellAttrs.className = (0, _classnames2.default)(cellAttrs.className, cellClasses);
+      if (!_utils2.default.isEmptyObject(cellStyle)) cellAttrs.style = cellStyle;
+
+      var children = footerFormatter ? footerFormatter(column, index, { text: text }) : text;
+
+      return _react2.default.createElement('th', cellAttrs, children);
+    }
+  }]);
+
+  return FooterCell;
+}((0, _cellEventDelegater2.default)(_react2.default.Component));
+
 FooterCell.propTypes = {
-  columnData: PropTypes.array,
-  index: PropTypes.number,
-  column: PropTypes.object
+  columnData: _propTypes2.default.array,
+  index: _propTypes2.default.number,
+  column: _propTypes2.default.object
 };
-export default FooterCell;
+
+exports.default = FooterCell;

lib/src/footer.js

@@ -1,19 +0,39 @@
-/* eslint react/require-default-props: 0 */
-import React from 'react';
-import PropTypes from 'prop-types';
-import RowTemplate from './row/row-template';
-import FooterCell from './footer-cell';
-import _ from './utils';
+'use strict';
 
-const Footer = props => {
-  const {
-    data,
-    className,
-    columns,
-    selectRow,
-    expandRow
-  } = props;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _rowTemplate = require('./row/row-template');
+
+var _rowTemplate2 = _interopRequireDefault(_rowTemplate);
+
+var _footerCell = require('./footer-cell');
+
+var _footerCell2 = _interopRequireDefault(_footerCell);
+
+var _utils = require('./utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var Footer = function Footer(props) {
+  var data = props.data,
+      className = props.className,
+      columns = props.columns,
+      selectRow = props.selectRow,
+      expandRow = props.expandRow;
+
+
   function renderContent() {
-    return columns.map((column, i) => {
+    return columns.map(function (column, i) {
       if (column.footer === undefined || column.footer === null) {
@@ -23,5 +43,5 @@ return false;
 
-      const columnData = _.pluck(data, column.dataField);
+      var columnData = _utils2.default.pluck(data, column.dataField);
 
-      return /*#__PURE__*/React.createElement(FooterCell, {
+      return _react2.default.createElement(_footerCell2.default, {
         index: i,
@@ -35,18 +55,24 @@ key: column.dataField,
 
-  return /*#__PURE__*/React.createElement("tfoot", null, /*#__PURE__*/React.createElement(RowTemplate, {
-    renderContent: renderContent,
-    selectRow: selectRow,
-    expandRow: expandRow,
-    className: className,
-    cellEl: "th"
-  }));
-};
+  return _react2.default.createElement(
+    'tfoot',
+    null,
+    _react2.default.createElement(_rowTemplate2.default, {
+      renderContent: renderContent,
+      selectRow: selectRow,
+      expandRow: expandRow,
+      className: className,
+      cellEl: 'th'
+    })
+  );
+}; /* eslint react/require-default-props: 0 */
 
+
 Footer.propTypes = {
-  data: PropTypes.array,
-  className: PropTypes.string,
-  columns: PropTypes.array,
-  selectRow: PropTypes.object,
-  expandRow: PropTypes.object
+  data: _propTypes2.default.array,
+  className: _propTypes2.default.string,
+  columns: _propTypes2.default.array,
+  selectRow: _propTypes2.default.object,
+  expandRow: _propTypes2.default.object
 };
-export default Footer;
+
+exports.default = Footer;

lib/src/header-cell.js

@@ -1,181 +0,226 @@
-function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+'use strict';
 
-/* eslint react/require-default-props: 0 */
-import React from 'react';
-import cs from 'classnames';
-import PropTypes from 'prop-types';
-import Const from './const';
-import SortSymbol from './sort/symbol';
-import SortCaret from './sort/caret';
-import _ from './utils';
-import eventDelegater from './cell-event-delegater';
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-class HeaderCell extends eventDelegater(React.Component) {
-  render() {
-    const {
-      column,
-      index,
-      onSort,
-      sorting,
-      sortOrder,
-      isLastSorting,
-      onFilter,
-      currFilters,
-      filterPosition,
-      onExternalFilter,
-      globalSortCaret
-    } = this.props;
-    const {
-      text,
-      sort,
-      sortCaret,
-      filter,
-      filterRenderer,
-      headerTitle,
-      headerAlign,
-      headerFormatter,
-      headerEvents,
-      headerClasses,
-      headerStyle,
-      headerAttrs,
-      headerSortingClasses,
-      headerSortingStyle
-    } = column;
-    const sortCaretfunc = sortCaret || globalSortCaret;
-    const delegateEvents = this.delegate(headerEvents);
-    const customAttrs = _.isFunction(headerAttrs) ? headerAttrs(column, index) : headerAttrs || {};
-    const cellAttrs = { ...customAttrs,
-      ...delegateEvents,
-      tabIndex: _.isDefined(customAttrs.tabIndex) ? customAttrs.tabIndex : 0
-    };
-    let sortSymbol;
-    let filterElm;
-    let cellStyle = {};
-    let cellClasses = _.isFunction(headerClasses) ? headerClasses(column, index) : headerClasses;
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
 
-    if (headerStyle) {
-      cellStyle = _.isFunction(headerStyle) ? headerStyle(column, index) : headerStyle;
-      cellStyle = cellStyle ? { ...cellStyle
-      } : cellStyle;
-    }
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-    if (headerTitle) {
-      cellAttrs.title = _.isFunction(headerTitle) ? headerTitle(column, index) : text;
-    }
+var _react = require('react');
 
-    if (headerAlign) {
-      cellStyle.textAlign = _.isFunction(headerAlign) ? headerAlign(column, index) : headerAlign;
-    }
+var _react2 = _interopRequireDefault(_react);
 
-    if (sort) {
-      const customClick = cellAttrs.onClick;
-      cellAttrs['aria-label'] = sorting ? `${text} sort ${sortOrder}` : `${text} sortable`;
+var _classnames = require('classnames');
 
-      cellAttrs.onKeyUp = e => {
-        if (e.key === 'Enter') {
-          onSort(column);
-          if (_.isFunction(customClick)) customClick(e);
-        }
-      };
+var _classnames2 = _interopRequireDefault(_classnames);
 
-      cellAttrs.onClick = e => {
-        onSort(column);
-        if (_.isFunction(customClick)) customClick(e);
-      };
+var _propTypes = require('prop-types');
 
-      cellAttrs.className = cs(cellAttrs.className, 'sortable');
+var _propTypes2 = _interopRequireDefault(_propTypes);
 
-      if (sorting) {
-        sortSymbol = sortCaretfunc ? sortCaretfunc(sortOrder, column) : /*#__PURE__*/React.createElement(SortCaret, {
-          order: sortOrder
-        }); // append customized classes or style if table was sorting based on the current column.
+var _const = require('./const');
 
-        cellClasses = cs(cellClasses, _.isFunction(headerSortingClasses) ? headerSortingClasses(column, sortOrder, isLastSorting, index) : headerSortingClasses);
-        cellStyle = { ...cellStyle,
-          ...(_.isFunction(headerSortingStyle) ? headerSortingStyle(column, sortOrder, isLastSorting, index) : headerSortingStyle)
+var _const2 = _interopRequireDefault(_const);
+
+var _symbol = require('./sort/symbol');
+
+var _symbol2 = _interopRequireDefault(_symbol);
+
+var _caret = require('./sort/caret');
+
+var _caret2 = _interopRequireDefault(_caret);
+
+var _utils = require('./utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+var _cellEventDelegater = require('./cell-event-delegater');
+
+var _cellEventDelegater2 = _interopRequireDefault(_cellEventDelegater);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint react/require-default-props: 0 */
+
+
+var HeaderCell = function (_eventDelegater) {
+  _inherits(HeaderCell, _eventDelegater);
+
+  function HeaderCell() {
+    _classCallCheck(this, HeaderCell);
+
+    return _possibleConstructorReturn(this, (HeaderCell.__proto__ || Object.getPrototypeOf(HeaderCell)).apply(this, arguments));
+  }
+
+  _createClass(HeaderCell, [{
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          column = _props.column,
+          index = _props.index,
+          onSort = _props.onSort,
+          sorting = _props.sorting,
+          sortOrder = _props.sortOrder,
+          isLastSorting = _props.isLastSorting,
+          onFilter = _props.onFilter,
+          currFilters = _props.currFilters,
+          filterPosition = _props.filterPosition,
+          onExternalFilter = _props.onExternalFilter,
+          globalSortCaret = _props.globalSortCaret;
+      var text = column.text,
+          sort = column.sort,
+          sortCaret = column.sortCaret,
+          filter = column.filter,
+          filterRenderer = column.filterRenderer,
+          headerTitle = column.headerTitle,
+          headerAlign = column.headerAlign,
+          headerFormatter = column.headerFormatter,
+          headerEvents = column.headerEvents,
+          headerClasses = column.headerClasses,
+          headerStyle = column.headerStyle,
+          headerAttrs = column.headerAttrs,
+          headerSortingClasses = column.headerSortingClasses,
+          headerSortingStyle = column.headerSortingStyle;
+
+
+      var sortCaretfunc = sortCaret || globalSortCaret;
+
+      var delegateEvents = this.delegate(headerEvents);
+
+      var customAttrs = _utils2.default.isFunction(headerAttrs) ? headerAttrs(column, index) : headerAttrs || {};
+
+      var cellAttrs = _extends({}, customAttrs, delegateEvents, {
+        tabIndex: _utils2.default.isDefined(customAttrs.tabIndex) ? customAttrs.tabIndex : 0
+      });
+
+      var sortSymbol = void 0;
+      var filterElm = void 0;
+      var cellStyle = {};
+      var cellClasses = _utils2.default.isFunction(headerClasses) ? headerClasses(column, index) : headerClasses;
+
+      if (headerStyle) {
+        cellStyle = _utils2.default.isFunction(headerStyle) ? headerStyle(column, index) : headerStyle;
+        cellStyle = cellStyle ? _extends({}, cellStyle) : cellStyle;
+      }
+
+      if (headerTitle) {
+        cellAttrs.title = _utils2.default.isFunction(headerTitle) ? headerTitle(column, index) : text;
+      }
+
+      if (headerAlign) {
+        cellStyle.textAlign = _utils2.default.isFunction(headerAlign) ? headerAlign(column, index) : headerAlign;
+      }
+
+      if (sort) {
+        var customClick = cellAttrs.onClick;
+        cellAttrs['aria-label'] = sorting ? text + ' sort ' + sortOrder : text + ' sortable';
+        cellAttrs.onKeyUp = function (e) {
+          if (e.key === 'Enter') {
+            onSort(column);
+            if (_utils2.default.isFunction(customClick)) customClick(e);
+          }
         };
-      } else {
-        sortSymbol = sortCaretfunc ? sortCaretfunc(undefined, column) : /*#__PURE__*/React.createElement(SortSymbol, null);
+        cellAttrs.onClick = function (e) {
+          onSort(column);
+          if (_utils2.default.isFunction(customClick)) customClick(e);
+        };
+        cellAttrs.className = (0, _classnames2.default)(cellAttrs.className, 'sortable');
+
+        if (sorting) {
+          sortSymbol = sortCaretfunc ? sortCaretfunc(sortOrder, column) : _react2.default.createElement(_caret2.default, { order: sortOrder });
+
+          // append customized classes or style if table was sorting based on the current column.
+          cellClasses = (0, _classnames2.default)(cellClasses, _utils2.default.isFunction(headerSortingClasses) ? headerSortingClasses(column, sortOrder, isLastSorting, index) : headerSortingClasses);
+
+          cellStyle = _extends({}, cellStyle, _utils2.default.isFunction(headerSortingStyle) ? headerSortingStyle(column, sortOrder, isLastSorting, index) : headerSortingStyle);
+        } else {
+          sortSymbol = sortCaretfunc ? sortCaretfunc(undefined, column) : _react2.default.createElement(_symbol2.default, null);
+        }
       }
-    }
 
-    if (cellClasses) cellAttrs.className = cs(cellAttrs.className, cellClasses);
-    if (!_.isEmptyObject(cellStyle)) cellAttrs.style = cellStyle;
+      if (cellClasses) cellAttrs.className = (0, _classnames2.default)(cellAttrs.className, cellClasses);
+      if (!_utils2.default.isEmptyObject(cellStyle)) cellAttrs.style = cellStyle;
 
-    if (filterPosition === Const.FILTERS_POSITION_INLINE) {
-      if (filterRenderer) {
-        const onCustomFilter = onExternalFilter(column, filter.props.type);
-        filterElm = filterRenderer(onCustomFilter, column);
-      } else if (filter) {
-        filterElm = /*#__PURE__*/React.createElement(filter.Filter, _extends({}, filter.props, {
-          filterState: currFilters[column.dataField],
-          onFilter: onFilter,
-          column: column
-        }));
+      if (filterPosition === _const2.default.FILTERS_POSITION_INLINE) {
+        if (filterRenderer) {
+          var onCustomFilter = onExternalFilter(column, filter.props.type);
+          filterElm = filterRenderer(onCustomFilter, column);
+        } else if (filter) {
+          filterElm = _react2.default.createElement(filter.Filter, _extends({}, filter.props, {
+            filterState: currFilters[column.dataField],
+            onFilter: onFilter,
+            column: column
+          }));
+        }
       }
-    }
 
-    const children = headerFormatter ? headerFormatter(column, index, {
-      sortElement: sortSymbol,
-      filterElement: filterElm
-    }) : text;
+      var children = headerFormatter ? headerFormatter(column, index, { sortElement: sortSymbol, filterElement: filterElm }) : text;
 
-    if (headerFormatter) {
-      return /*#__PURE__*/React.createElement('th', cellAttrs, children);
+      if (headerFormatter) {
+        return _react2.default.createElement('th', cellAttrs, children);
+      }
+
+      return _react2.default.createElement('th', cellAttrs, children, sortSymbol, filterElm);
     }
+  }]);
 
-    return /*#__PURE__*/React.createElement('th', cellAttrs, children, sortSymbol, filterElm);
-  }
+  return HeaderCell;
+}((0, _cellEventDelegater2.default)(_react2.default.Component));
 
-}
-
 HeaderCell.propTypes = {
-  column: PropTypes.shape({
-    dataField: PropTypes.string.isRequired,
-    text: PropTypes.string.isRequired,
-    type: PropTypes.oneOf([Const.TYPE_STRING, Const.TYPE_NUMBER, Const.TYPE_BOOLEAN, Const.TYPE_DATE]),
-    isDummyField: PropTypes.bool,
-    hidden: PropTypes.bool,
-    headerFormatter: PropTypes.func,
-    formatter: PropTypes.func,
-    formatExtraData: PropTypes.any,
-    headerClasses: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
-    classes: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
-    headerStyle: PropTypes.oneOfType([PropTypes.object, PropTypes.func]),
-    style: PropTypes.oneOfType([PropTypes.object, PropTypes.func]),
-    headerTitle: PropTypes.oneOfType([PropTypes.bool, PropTypes.func]),
-    title: PropTypes.oneOfType([PropTypes.bool, PropTypes.func]),
-    headerEvents: PropTypes.object,
-    events: PropTypes.object,
-    headerAlign: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
-    align: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
-    headerAttrs: PropTypes.oneOfType([PropTypes.object, PropTypes.func]),
-    attrs: PropTypes.oneOfType([PropTypes.object, PropTypes.func]),
-    sort: PropTypes.bool,
-    sortFunc: PropTypes.func,
-    onSort: PropTypes.func,
-    editor: PropTypes.object,
-    editable: PropTypes.oneOfType([PropTypes.bool, PropTypes.func]),
-    editCellStyle: PropTypes.oneOfType([PropTypes.object, PropTypes.func]),
-    editCellClasses: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
-    editorStyle: PropTypes.oneOfType([PropTypes.object, PropTypes.func]),
-    editorClasses: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
-    editorRenderer: PropTypes.func,
-    validator: PropTypes.func,
-    filter: PropTypes.object,
-    filterRenderer: PropTypes.func,
-    filterValue: PropTypes.func,
-    searchable: PropTypes.bool
+  column: _propTypes2.default.shape({
+    dataField: _propTypes2.default.string.isRequired,
+    text: _propTypes2.default.string.isRequired,
+    type: _propTypes2.default.oneOf([_const2.default.TYPE_STRING, _const2.default.TYPE_NUMBER, _const2.default.TYPE_BOOLEAN, _const2.default.TYPE_DATE]),
+    isDummyField: _propTypes2.default.bool,
+    hidden: _propTypes2.default.bool,
+    headerFormatter: _propTypes2.default.func,
+    formatter: _propTypes2.default.func,
+    formatExtraData: _propTypes2.default.any,
+    headerClasses: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.func]),
+    classes: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.func]),
+    headerStyle: _propTypes2.default.oneOfType([_propTypes2.default.object, _propTypes2.default.func]),
+    style: _propTypes2.default.oneOfType([_propTypes2.default.object, _propTypes2.default.func]),
+    headerTitle: _propTypes2.default.oneOfType([_propTypes2.default.bool, _propTypes2.default.func]),
+    title: _propTypes2.default.oneOfType([_propTypes2.default.bool, _propTypes2.default.func]),
+    headerEvents: _propTypes2.default.object,
+    events: _propTypes2.default.object,
+    headerAlign: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.func]),
+    align: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.func]),
+    headerAttrs: _propTypes2.default.oneOfType([_propTypes2.default.object, _propTypes2.default.func]),
+    attrs: _propTypes2.default.oneOfType([_propTypes2.default.object, _propTypes2.default.func]),
+    sort: _propTypes2.default.bool,
+    sortFunc: _propTypes2.default.func,
+    onSort: _propTypes2.default.func,
+    editor: _propTypes2.default.object,
+    editable: _propTypes2.default.oneOfType([_propTypes2.default.bool, _propTypes2.default.func]),
+    editCellStyle: _propTypes2.default.oneOfType([_propTypes2.default.object, _propTypes2.default.func]),
+    editCellClasses: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.func]),
+    editorStyle: _propTypes2.default.oneOfType([_propTypes2.default.object, _propTypes2.default.func]),
+    editorClasses: _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.func]),
+    editorRenderer: _propTypes2.default.func,
+    validator: _propTypes2.default.func,
+    filter: _propTypes2.default.object,
+    filterRenderer: _propTypes2.default.func,
+    filterValue: _propTypes2.default.func,
+    searchable: _propTypes2.default.bool
   }).isRequired,
-  index: PropTypes.number.isRequired,
-  onSort: PropTypes.func,
-  sorting: PropTypes.bool,
-  sortOrder: PropTypes.oneOf([Const.SORT_ASC, Const.SORT_DESC]),
-  sortCaret: PropTypes.func,
-  isLastSorting: PropTypes.bool,
-  onFilter: PropTypes.func,
-  filterPosition: PropTypes.oneOf([Const.FILTERS_POSITION_INLINE, Const.FILTERS_POSITION_BOTTOM, Const.FILTERS_POSITION_TOP]),
-  currFilters: PropTypes.object,
-  onExternalFilter: PropTypes.func
+  index: _propTypes2.default.number.isRequired,
+  onSort: _propTypes2.default.func,
+  sorting: _propTypes2.default.bool,
+  sortOrder: _propTypes2.default.oneOf([_const2.default.SORT_ASC, _const2.default.SORT_DESC]),
+  sortCaret: _propTypes2.default.func,
+  isLastSorting: _propTypes2.default.bool,
+  onFilter: _propTypes2.default.func,
+  filterPosition: _propTypes2.default.oneOf([_const2.default.FILTERS_POSITION_INLINE, _const2.default.FILTERS_POSITION_BOTTOM, _const2.default.FILTERS_POSITION_TOP]),
+  currFilters: _propTypes2.default.object,
+  onExternalFilter: _propTypes2.default.func
 };
-export default HeaderCell;
+
+exports.default = HeaderCell;

lib/src/header.js

@@ -0,46 +1,83 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _headerCell = require('./header-cell');
+
+var _headerCell2 = _interopRequireDefault(_headerCell);
+
+var _selectionHeaderCell = require('./row-selection/selection-header-cell');
+
+var _selectionHeaderCell2 = _interopRequireDefault(_selectionHeaderCell);
+
+var _expandHeaderCell = require('./row-expand/expand-header-cell');
+
+var _expandHeaderCell2 = _interopRequireDefault(_expandHeaderCell);
+
+var _selectionHeaderCellConsumer = require('./row-selection/selection-header-cell-consumer');
+
+var _selectionHeaderCellConsumer2 = _interopRequireDefault(_selectionHeaderCellConsumer);
+
+var _expandHeaderCellConsumer = require('./row-expand/expand-header-cell-consumer');
+
+var _expandHeaderCellConsumer2 = _interopRequireDefault(_expandHeaderCellConsumer);
+
+var _const = require('./const');
+
+var _const2 = _interopRequireDefault(_const);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 /* eslint react/require-default-props: 0 */
-import React from 'react';
-import PropTypes from 'prop-types';
-import HeaderCell from './header-cell';
-import SelectionHeaderCell from './row-selection/selection-header-cell';
-import ExpandHeaderCell from './row-expand/expand-header-cell';
-import withHeaderSelection from './row-selection/selection-header-cell-consumer';
-import withHeaderExpansion from './row-expand/expand-header-cell-consumer';
-import Const from './const';
+var Header = function Header(props) {
+  var className = props.className,
+      columns = props.columns,
+      onSort = props.onSort,
+      onFilter = props.onFilter,
+      sortField = props.sortField,
+      sortOrder = props.sortOrder,
+      selectRow = props.selectRow,
+      expandRow = props.expandRow,
+      currFilters = props.currFilters,
+      onExternalFilter = props.onExternalFilter,
+      filterPosition = props.filterPosition,
+      globalSortCaret = props.globalSortCaret,
+      wrapperClasses = props.wrapperClasses;
 
-const Header = props => {
-  const {
-    className,
-    columns,
-    onSort,
-    onFilter,
-    sortField,
-    sortOrder,
-    selectRow,
-    expandRow,
-    currFilters,
-    onExternalFilter,
-    filterPosition,
-    globalSortCaret,
-    wrapperClasses
-  } = props;
 
-  let SelectionHeaderCellComp = () => null;
+  var SelectionHeaderCellComp = function SelectionHeaderCellComp() {
+    return null;
+  };
+  var ExpansionHeaderCellComp = function ExpansionHeaderCellComp() {
+    return null;
+  };
 
-  let ExpansionHeaderCellComp = () => null;
-
   if (expandRow.showExpandColumn) {
-    ExpansionHeaderCellComp = withHeaderExpansion(ExpandHeaderCell);
+    ExpansionHeaderCellComp = (0, _expandHeaderCellConsumer2.default)(_expandHeaderCell2.default);
   }
 
   if (selectRow) {
-    SelectionHeaderCellComp = withHeaderSelection(SelectionHeaderCell);
+    SelectionHeaderCellComp = (0, _selectionHeaderCellConsumer2.default)(_selectionHeaderCell2.default);
   }
 
-  const isRenderFunctionColumnInLeft = (position = Const.INDICATOR_POSITION_LEFT) => position === Const.INDICATOR_POSITION_LEFT;
+  var isRenderFunctionColumnInLeft = function isRenderFunctionColumnInLeft() {
+    var position = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _const2.default.INDICATOR_POSITION_LEFT;
+    return position === _const2.default.INDICATOR_POSITION_LEFT;
+  };
 
-  const childrens = [columns.map((column, i) => {
-    const currSort = column.dataField === sortField;
-    const isLastSorting = column.dataField === sortField;
-    return /*#__PURE__*/React.createElement(HeaderCell, {
+  var childrens = [columns.map(function (column, i) {
+    var currSort = column.dataField === sortField;
+    var isLastSorting = column.dataField === sortField;
+
+    return _react2.default.createElement(_headerCell2.default, {
       index: i,
@@ -63,9 +100,5 @@ key: column.dataField,
     if (isRenderFunctionColumnInLeft(selectRow.selectColumnPosition)) {
-      childrens.unshift( /*#__PURE__*/React.createElement(SelectionHeaderCellComp, {
-        key: "selection"
-      }));
+      childrens.unshift(_react2.default.createElement(SelectionHeaderCellComp, { key: 'selection' }));
     } else {
-      childrens.push( /*#__PURE__*/React.createElement(SelectionHeaderCellComp, {
-        key: "selection"
-      }));
+      childrens.push(_react2.default.createElement(SelectionHeaderCellComp, { key: 'selection' }));
     }
@@ -76,34 +109,35 @@ }
     if (isRenderFunctionColumnInLeft(expandRow.expandColumnPosition)) {
-      childrens.unshift( /*#__PURE__*/React.createElement(ExpansionHeaderCellComp, {
-        key: "expansion"
-      }));
+      childrens.unshift(_react2.default.createElement(ExpansionHeaderCellComp, { key: 'expansion' }));
     } else {
-      childrens.push( /*#__PURE__*/React.createElement(ExpansionHeaderCellComp, {
-        key: "expansion"
-      }));
+      childrens.push(_react2.default.createElement(ExpansionHeaderCellComp, { key: 'expansion' }));
     }
   }
 
-  return /*#__PURE__*/React.createElement("thead", {
-    className: wrapperClasses
-  }, /*#__PURE__*/React.createElement("tr", {
-    className: className
-  }, childrens));
+  return _react2.default.createElement(
+    'thead',
+    { className: wrapperClasses },
+    _react2.default.createElement(
+      'tr',
+      { className: className },
+      childrens
+    )
+  );
 };
 
 Header.propTypes = {
-  columns: PropTypes.array.isRequired,
-  onSort: PropTypes.func,
-  onFilter: PropTypes.func,
-  sortField: PropTypes.string,
-  sortOrder: PropTypes.string,
-  selectRow: PropTypes.object,
-  currFilters: PropTypes.object,
-  onExternalFilter: PropTypes.func,
-  globalSortCaret: PropTypes.func,
-  className: PropTypes.string,
-  wrapperClasses: PropTypes.string,
-  expandRow: PropTypes.object,
-  filterPosition: PropTypes.oneOf([Const.FILTERS_POSITION_TOP, Const.FILTERS_POSITION_INLINE, Const.FILTERS_POSITION_BOTTOM])
+  columns: _propTypes2.default.array.isRequired,
+  onSort: _propTypes2.default.func,
+  onFilter: _propTypes2.default.func,
+  sortField: _propTypes2.default.string,
+  sortOrder: _propTypes2.default.string,
+  selectRow: _propTypes2.default.object,
+  currFilters: _propTypes2.default.object,
+  onExternalFilter: _propTypes2.default.func,
+  globalSortCaret: _propTypes2.default.func,
+  className: _propTypes2.default.string,
+  wrapperClasses: _propTypes2.default.string,
+  expandRow: _propTypes2.default.object,
+  filterPosition: _propTypes2.default.oneOf([_const2.default.FILTERS_POSITION_TOP, _const2.default.FILTERS_POSITION_INLINE, _const2.default.FILTERS_POSITION_BOTTOM])
 };
-export default Header;
+
+exports.default = Header;

lib/src/props-resolver/column-resolver.js

@@ -1,25 +0,54 @@
-export default (ExtendBase => class ColumnResolver extends ExtendBase {
-  visibleColumnSize(includeSelectColumn = true) {
-    let columnLen;
+"use strict";
 
-    if (this.props.columnToggle && this.props.columnToggle.toggles) {
-      const columns = this.props.columnToggle.toggles;
-      columnLen = Object.keys(columns).filter(name => columns[name]).length;
-    } else {
-      columnLen = this.props.columns.filter(c => !c.hidden).length;
-    }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-    if (!includeSelectColumn) return columnLen;
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-    if (this.props.selectRow && !this.props.selectRow.hideSelectColumn) {
-      columnLen += 1;
-    }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-    if (this.props.expandRow && this.props.expandRow.showExpandColumn) {
-      columnLen += 1;
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+exports.default = function (ExtendBase) {
+  return function (_ExtendBase) {
+    _inherits(ColumnResolver, _ExtendBase);
+
+    function ColumnResolver() {
+      _classCallCheck(this, ColumnResolver);
+
+      return _possibleConstructorReturn(this, (ColumnResolver.__proto__ || Object.getPrototypeOf(ColumnResolver)).apply(this, arguments));
     }
 
-    return columnLen;
-  }
+    _createClass(ColumnResolver, [{
+      key: "visibleColumnSize",
+      value: function visibleColumnSize() {
+        var includeSelectColumn = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
 
-});
+        var columnLen = void 0;
+        if (this.props.columnToggle && this.props.columnToggle.toggles) {
+          var columns = this.props.columnToggle.toggles;
+          columnLen = Object.keys(columns).filter(function (name) {
+            return columns[name];
+          }).length;
+        } else {
+          columnLen = this.props.columns.filter(function (c) {
+            return !c.hidden;
+          }).length;
+        }
+        if (!includeSelectColumn) return columnLen;
+        if (this.props.selectRow && !this.props.selectRow.hideSelectColumn) {
+          columnLen += 1;
+        }
+        if (this.props.expandRow && this.props.expandRow.showExpandColumn) {
+          columnLen += 1;
+        }
+        return columnLen;
+      }
+    }]);
+
+    return ColumnResolver;
+  }(ExtendBase);
+};

lib/src/props-resolver/index.js

@@ -1,36 +0,70 @@
-import _ from '../utils';
-import ColumnResolver from './column-resolver';
-export default (ExtendBase => class TableResolver extends ColumnResolver(ExtendBase) {
-  validateProps() {
-    const {
-      keyField
-    } = this.props;
+'use strict';
 
-    if (!keyField) {
-      throw new Error('Please specify a field as key via keyField');
-    }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-    if (this.visibleColumnSize(false) <= 0) {
-      throw new Error('No visible columns detected');
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _utils = require('../utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+var _columnResolver = require('./column-resolver');
+
+var _columnResolver2 = _interopRequireDefault(_columnResolver);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+exports.default = function (ExtendBase) {
+  return function (_ColumnResolver) {
+    _inherits(TableResolver, _ColumnResolver);
+
+    function TableResolver() {
+      _classCallCheck(this, TableResolver);
+
+      return _possibleConstructorReturn(this, (TableResolver.__proto__ || Object.getPrototypeOf(TableResolver)).apply(this, arguments));
     }
-  }
 
-  isEmpty() {
-    return this.props.data.length === 0;
-  }
+    _createClass(TableResolver, [{
+      key: 'validateProps',
+      value: function validateProps() {
+        var keyField = this.props.keyField;
 
-  visibleRows() {
-    const {
-      data,
-      hiddenRows,
-      keyField
-    } = this.props;
-    if (!hiddenRows || hiddenRows.length === 0) return data;
-    return data.filter(row => {
-      const key = _.get(row, keyField);
+        if (!keyField) {
+          throw new Error('Please specify a field as key via keyField');
+        }
+        if (this.visibleColumnSize(false) <= 0) {
+          throw new Error('No visible columns detected');
+        }
+      }
+    }, {
+      key: 'isEmpty',
+      value: function isEmpty() {
+        return this.props.data.length === 0;
+      }
+    }, {
+      key: 'visibleRows',
+      value: function visibleRows() {
+        var _props = this.props,
+            data = _props.data,
+            hiddenRows = _props.hiddenRows,
+            keyField = _props.keyField;
 
-      return !_.contains(hiddenRows, key);
-    });
-  }
+        if (!hiddenRows || hiddenRows.length === 0) return data;
+        return data.filter(function (row) {
+          var key = _utils2.default.get(row, keyField);
+          return !_utils2.default.contains(hiddenRows, key);
+        });
+      }
+    }]);
 
-});
+    return TableResolver;
+  }((0, _columnResolver2.default)(ExtendBase));
+};

lib/src/props-resolver/remote-resolver.js

@@ -1,118 +0,140 @@
-import EventEmitter from 'events';
-import _ from '../utils';
-export default (ExtendBase => class RemoteResolver extends ExtendBase {
-  constructor(props) {
-    super(props);
-    this.remoteEmitter = new EventEmitter();
-    this.remoteEmitter.on('paginationChange', this.handleRemotePageChange);
-    this.remoteEmitter.on('isRemotePagination', this.isRemotePagination);
-  }
+'use strict';
 
-  getNewestState = (state = {}) => {
-    let sortOrder;
-    let sortField;
-    let page;
-    let sizePerPage;
-    let searchText;
-    let filters = {};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-    if (this.sortContext) {
-      sortOrder = this.sortContext.state.sortOrder;
-      sortField = this.sortContext.state.sortColumn ? this.sortContext.state.sortColumn.dataField : null;
-    }
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
 
-    if (this.filterContext) {
-      filters = this.filterContext.currFilters;
-    }
+var _events = require('events');
 
-    if (this.paginationContext) {
-      page = this.paginationContext.currPage;
-      sizePerPage = this.paginationContext.currSizePerPage;
-    }
+var _events2 = _interopRequireDefault(_events);
 
-    if (this.searchContext) {
-      searchText = this.props.search.searchText;
-    }
+var _utils = require('../utils');
 
-    return {
-      sortOrder,
-      sortField,
-      filters,
-      page,
-      sizePerPage,
-      searchText,
-      ...state,
-      data: this.props.data
-    };
-  };
-  isRemoteSearch = () => {
-    const {
-      remote
-    } = this.props;
-    return remote === true || _.isObject(remote) && remote.search || this.isRemotePagination();
-  };
-  isRemotePagination = (e = {}) => {
-    const {
-      remote
-    } = this.props;
-    e.result = remote === true || _.isObject(remote) && remote.pagination;
-    return e.result;
-  };
-  isRemoteFiltering = () => {
-    const {
-      remote
-    } = this.props;
-    return remote === true || _.isObject(remote) && remote.filter || this.isRemotePagination();
-  };
-  isRemoteSort = () => {
-    const {
-      remote
-    } = this.props;
-    return remote === true || _.isObject(remote) && remote.sort || this.isRemotePagination();
-  };
-  isRemoteCellEdit = () => {
-    const {
-      remote
-    } = this.props;
-    return remote === true || _.isObject(remote) && remote.cellEdit;
-  };
-  handleRemotePageChange = (page, sizePerPage) => {
-    this.props.onTableChange('pagination', this.getNewestState({
-      page,
-      sizePerPage
-    }));
-  };
-  handleRemoteFilterChange = filters => {
-    const newState = {
-      filters
-    };
+var _utils2 = _interopRequireDefault(_utils);
 
-    if (this.isRemotePagination()) {
-      const options = this.props.pagination.options || {};
-      newState.page = _.isDefined(options.pageStartIndex) ? options.pageStartIndex : 1;
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+exports.default = function (ExtendBase) {
+  return function (_ExtendBase) {
+    _inherits(RemoteResolver, _ExtendBase);
+
+    function RemoteResolver(props) {
+      _classCallCheck(this, RemoteResolver);
+
+      var _this = _possibleConstructorReturn(this, (RemoteResolver.__proto__ || Object.getPrototypeOf(RemoteResolver)).call(this, props));
+
+      _this.getNewestState = function () {
+        var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+        var sortOrder = void 0;
+        var sortField = void 0;
+        var page = void 0;
+        var sizePerPage = void 0;
+        var searchText = void 0;
+        var filters = {};
+
+        if (_this.sortContext) {
+          sortOrder = _this.sortContext.state.sortOrder;
+          sortField = _this.sortContext.state.sortColumn ? _this.sortContext.state.sortColumn.dataField : null;
+        }
+
+        if (_this.filterContext) {
+          filters = _this.filterContext.currFilters;
+        }
+
+        if (_this.paginationContext) {
+          page = _this.paginationContext.currPage;
+          sizePerPage = _this.paginationContext.currSizePerPage;
+        }
+
+        if (_this.searchContext) {
+          searchText = _this.props.search.searchText;
+        }
+
+        return _extends({
+          sortOrder: sortOrder,
+          sortField: sortField,
+          filters: filters,
+          page: page,
+          sizePerPage: sizePerPage,
+          searchText: searchText
+        }, state, {
+          data: _this.props.data
+        });
+      };
+
+      _this.isRemoteSearch = function () {
+        var remote = _this.props.remote;
+
+        return remote === true || _utils2.default.isObject(remote) && remote.search || _this.isRemotePagination();
+      };
+
+      _this.isRemotePagination = function () {
+        var e = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+        var remote = _this.props.remote;
+
+        e.result = remote === true || _utils2.default.isObject(remote) && remote.pagination;
+        return e.result;
+      };
+
+      _this.isRemoteFiltering = function () {
+        var remote = _this.props.remote;
+
+        return remote === true || _utils2.default.isObject(remote) && remote.filter || _this.isRemotePagination();
+      };
+
+      _this.isRemoteSort = function () {
+        var remote = _this.props.remote;
+
+        return remote === true || _utils2.default.isObject(remote) && remote.sort || _this.isRemotePagination();
+      };
+
+      _this.isRemoteCellEdit = function () {
+        var remote = _this.props.remote;
+
+        return remote === true || _utils2.default.isObject(remote) && remote.cellEdit;
+      };
+
+      _this.handleRemotePageChange = function (page, sizePerPage) {
+        _this.props.onTableChange('pagination', _this.getNewestState({ page: page, sizePerPage: sizePerPage }));
+      };
+
+      _this.handleRemoteFilterChange = function (filters) {
+        var newState = { filters: filters };
+        if (_this.isRemotePagination()) {
+          var options = _this.props.pagination.options || {};
+          newState.page = _utils2.default.isDefined(options.pageStartIndex) ? options.pageStartIndex : 1;
+        }
+        _this.props.onTableChange('filter', _this.getNewestState(newState));
+      };
+
+      _this.handleRemoteSortChange = function (sortField, sortOrder) {
+        _this.props.onTableChange('sort', _this.getNewestState({ sortField: sortField, sortOrder: sortOrder }));
+      };
+
+      _this.handleRemoteCellChange = function (rowId, dataField, newValue) {
+        var cellEdit = { rowId: rowId, dataField: dataField, newValue: newValue };
+        _this.props.onTableChange('cellEdit', _this.getNewestState({ cellEdit: cellEdit }));
+      };
+
+      _this.handleRemoteSearchChange = function (searchText) {
+        _this.props.onTableChange('search', _this.getNewestState({ searchText: searchText }));
+      };
+
+      _this.remoteEmitter = new _events2.default();
+      _this.remoteEmitter.on('paginationChange', _this.handleRemotePageChange);
+      _this.remoteEmitter.on('isRemotePagination', _this.isRemotePagination);
+      return _this;
     }
 
-    this.props.onTableChange('filter', this.getNewestState(newState));
-  };
-  handleRemoteSortChange = (sortField, sortOrder) => {
-    this.props.onTableChange('sort', this.getNewestState({
-      sortField,
-      sortOrder
-    }));
-  };
-  handleRemoteCellChange = (rowId, dataField, newValue) => {
-    const cellEdit = {
-      rowId,
-      dataField,
-      newValue
-    };
-    this.props.onTableChange('cellEdit', this.getNewestState({
-      cellEdit
-    }));
-  };
-  handleRemoteSearchChange = searchText => {
-    this.props.onTableChange('search', this.getNewestState({
-      searchText
-    }));
-  };
-});
+    return RemoteResolver;
+  }(ExtendBase);
+};

lib/src/row-expand/expand-cell.js

@@ -1,63 +0,100 @@
-function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+'use strict';
 
-/* eslint
-  react/require-default-props: 0
-  jsx-a11y/no-noninteractive-element-interactions: 0
-*/
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 react/require-default-props: 0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 jsx-a11y/no-noninteractive-element-interactions: 0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               */
 /* eslint no-nested-ternary: 0 */
-import React, { Component } from 'react';
-import PropTypes from 'prop-types';
-export default class ExpandCell extends Component {
-  static propTypes = {
-    rowKey: PropTypes.any,
-    expanded: PropTypes.bool.isRequired,
-    expandable: PropTypes.bool.isRequired,
-    onRowExpand: PropTypes.func.isRequired,
-    expandColumnRenderer: PropTypes.func,
-    rowIndex: PropTypes.number,
-    tabIndex: PropTypes.number
-  };
 
-  constructor() {
-    super();
-    this.handleClick = this.handleClick.bind(this);
-  }
 
-  shouldComponentUpdate(nextProps) {
-    const shouldUpdate = this.props.rowIndex !== nextProps.rowIndex || this.props.expanded !== nextProps.expanded || this.props.rowKey !== nextProps.rowKey || this.props.tabIndex !== nextProps.tabIndex;
-    return shouldUpdate;
-  }
+var ExpandCell = function (_Component) {
+  _inherits(ExpandCell, _Component);
 
-  handleClick(e) {
-    const {
-      rowKey,
-      expanded,
-      onRowExpand,
-      rowIndex
-    } = this.props;
-    e.stopPropagation();
-    onRowExpand(rowKey, !expanded, rowIndex, e);
-  }
+  function ExpandCell() {
+    _classCallCheck(this, ExpandCell);
 
-  render() {
-    const {
-      expanded,
-      expandable,
-      expandColumnRenderer,
-      tabIndex,
-      rowKey
-    } = this.props;
-    const attrs = {};
-    if (tabIndex !== -1) attrs.tabIndex = tabIndex;
-    return /*#__PURE__*/React.createElement("td", _extends({
-      className: "expand-cell",
-      onClick: this.handleClick
-    }, attrs), expandColumnRenderer ? expandColumnRenderer({
-      expandable,
-      expanded,
-      rowKey
-    }) : expandable ? expanded ? '(-)' : '(+)' : '');
+    var _this = _possibleConstructorReturn(this, (ExpandCell.__proto__ || Object.getPrototypeOf(ExpandCell)).call(this));
+
+    _this.handleClick = _this.handleClick.bind(_this);
+    return _this;
   }
 
-}
+  _createClass(ExpandCell, [{
+    key: 'shouldComponentUpdate',
+    value: function shouldComponentUpdate(nextProps) {
+      var shouldUpdate = this.props.rowIndex !== nextProps.rowIndex || this.props.expanded !== nextProps.expanded || this.props.rowKey !== nextProps.rowKey || this.props.tabIndex !== nextProps.tabIndex;
+
+      return shouldUpdate;
+    }
+  }, {
+    key: 'handleClick',
+    value: function handleClick(e) {
+      var _props = this.props,
+          rowKey = _props.rowKey,
+          expanded = _props.expanded,
+          onRowExpand = _props.onRowExpand,
+          rowIndex = _props.rowIndex;
+
+      e.stopPropagation();
+      onRowExpand(rowKey, !expanded, rowIndex, e);
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props2 = this.props,
+          expanded = _props2.expanded,
+          expandable = _props2.expandable,
+          expandColumnRenderer = _props2.expandColumnRenderer,
+          tabIndex = _props2.tabIndex,
+          rowKey = _props2.rowKey;
+
+      var attrs = {};
+      if (tabIndex !== -1) attrs.tabIndex = tabIndex;
+
+      return _react2.default.createElement(
+        'td',
+        _extends({ className: 'expand-cell', onClick: this.handleClick }, attrs),
+        expandColumnRenderer ? expandColumnRenderer({
+          expandable: expandable,
+          expanded: expanded,
+          rowKey: rowKey
+        }) : expandable ? expanded ? '(-)' : '(+)' : ''
+      );
+    }
+  }]);
+
+  return ExpandCell;
+}(_react.Component);
+
+ExpandCell.propTypes = {
+  rowKey: _propTypes2.default.any,
+  expanded: _propTypes2.default.bool.isRequired,
+  expandable: _propTypes2.default.bool.isRequired,
+  onRowExpand: _propTypes2.default.func.isRequired,
+  expandColumnRenderer: _propTypes2.default.func,
+  rowIndex: _propTypes2.default.number,
+  tabIndex: _propTypes2.default.number
+};
+exports.default = ExpandCell;

lib/src/row-expand/expand-header-cell-consumer.js

@@ -1,3 +0,27 @@
-import React from 'react';
-import ExpansionContext from '../contexts/row-expand-context';
-export default (Component => () => /*#__PURE__*/React.createElement(ExpansionContext.Consumer, null, expandRow => /*#__PURE__*/React.createElement(Component, expandRow)));
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _rowExpandContext = require('../contexts/row-expand-context');
+
+var _rowExpandContext2 = _interopRequireDefault(_rowExpandContext);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = function (Component) {
+  return function () {
+    return _react2.default.createElement(
+      _rowExpandContext2.default.Consumer,
+      null,
+      function (expandRow) {
+        return _react2.default.createElement(Component, expandRow);
+      }
+    );
+  };
+};

lib/src/row-expand/expand-header-cell.js

@@ -1,44 +0,78 @@
-function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+'use strict';
 
-/* eslint react/require-default-props: 0 */
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint react/require-default-props: 0 */
 /* eslint no-nested-ternary: 0 */
-import React, { Component } from 'react';
-import PropTypes from 'prop-types';
-export default class ExpansionHeaderCell extends Component {
-  static propTypes = {
-    isAnyExpands: PropTypes.bool.isRequired,
-    onAllRowExpand: PropTypes.func.isRequired,
-    expandHeaderColumnRenderer: PropTypes.func
-  };
 
-  constructor() {
-    super();
-    this.handleCheckBoxClick = this.handleCheckBoxClick.bind(this);
-  }
 
-  handleCheckBoxClick(e) {
-    const {
-      isAnyExpands,
-      onAllRowExpand
-    } = this.props;
-    onAllRowExpand(e, !isAnyExpands);
-  }
+var ExpansionHeaderCell = function (_Component) {
+  _inherits(ExpansionHeaderCell, _Component);
 
-  render() {
-    const {
-      isAnyExpands,
-      expandHeaderColumnRenderer
-    } = this.props;
-    const attrs = {
-      onClick: this.handleCheckBoxClick
-    };
-    return /*#__PURE__*/React.createElement("th", _extends({
-      className: "expand-cell-header",
-      "data-row-selection": true
-    }, attrs), expandHeaderColumnRenderer ? expandHeaderColumnRenderer({
-      isAnyExpands
-    }) : isAnyExpands ? '(-)' : '(+)');
+  function ExpansionHeaderCell() {
+    _classCallCheck(this, ExpansionHeaderCell);
+
+    var _this = _possibleConstructorReturn(this, (ExpansionHeaderCell.__proto__ || Object.getPrototypeOf(ExpansionHeaderCell)).call(this));
+
+    _this.handleCheckBoxClick = _this.handleCheckBoxClick.bind(_this);
+    return _this;
   }
 
-}
+  _createClass(ExpansionHeaderCell, [{
+    key: 'handleCheckBoxClick',
+    value: function handleCheckBoxClick(e) {
+      var _props = this.props,
+          isAnyExpands = _props.isAnyExpands,
+          onAllRowExpand = _props.onAllRowExpand;
+
+
+      onAllRowExpand(e, !isAnyExpands);
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props2 = this.props,
+          isAnyExpands = _props2.isAnyExpands,
+          expandHeaderColumnRenderer = _props2.expandHeaderColumnRenderer;
+
+      var attrs = {
+        onClick: this.handleCheckBoxClick
+      };
+
+      return _react2.default.createElement(
+        'th',
+        _extends({ className: 'expand-cell-header', 'data-row-selection': true }, attrs),
+        expandHeaderColumnRenderer ? expandHeaderColumnRenderer({ isAnyExpands: isAnyExpands }) : isAnyExpands ? '(-)' : '(+)'
+      );
+    }
+  }]);
+
+  return ExpansionHeaderCell;
+}(_react.Component);
+
+ExpansionHeaderCell.propTypes = {
+  isAnyExpands: _propTypes2.default.bool.isRequired,
+  onAllRowExpand: _propTypes2.default.func.isRequired,
+  expandHeaderColumnRenderer: _propTypes2.default.func
+};
+exports.default = ExpansionHeaderCell;

lib/src/row-expand/expand-row.js

@@ -1,32 +0,70 @@
-function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+'use strict';
 
-import cs from 'classnames';
-import React from 'react';
-import PropTypes from 'prop-types';
-import { CSSTransition } from 'react-transition-group';
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-const ExpandRow = ({
-  children,
-  expanded,
-  onClosed,
-  className,
-  ...rest
-}) => /*#__PURE__*/React.createElement("tr", null, /*#__PURE__*/React.createElement("td", _extends({
-  className: cs('reset-expansion-style', className)
-}, rest), /*#__PURE__*/React.createElement(CSSTransition, {
-  appear: true,
-  in: expanded,
-  timeout: 400,
-  classNames: "row-expand-slide",
-  onExited: onClosed
-}, /*#__PURE__*/React.createElement("div", null, /*#__PURE__*/React.createElement("div", {
-  className: "row-expansion-style"
-}, children)))));
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
 
+var _classnames = require('classnames');
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _reactTransitionGroup = require('react-transition-group');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
+
+var ExpandRow = function ExpandRow(_ref) {
+  var children = _ref.children,
+      expanded = _ref.expanded,
+      onClosed = _ref.onClosed,
+      className = _ref.className,
+      rest = _objectWithoutProperties(_ref, ['children', 'expanded', 'onClosed', 'className']);
+
+  return _react2.default.createElement(
+    'tr',
+    null,
+    _react2.default.createElement(
+      'td',
+      _extends({ className: (0, _classnames2.default)('reset-expansion-style', className) }, rest),
+      _react2.default.createElement(
+        _reactTransitionGroup.CSSTransition,
+        {
+          appear: true,
+          'in': expanded,
+          timeout: 400,
+          classNames: 'row-expand-slide',
+          onExited: onClosed
+        },
+        _react2.default.createElement(
+          'div',
+          null,
+          _react2.default.createElement(
+            'div',
+            { className: 'row-expansion-style' },
+            children
+          )
+        )
+      )
+    )
+  );
+};
+
 ExpandRow.propTypes = {
-  children: PropTypes.node,
-  expanded: PropTypes.bool,
-  onClosed: PropTypes.func,
-  className: PropTypes.string
+  children: _propTypes2.default.node,
+  expanded: _propTypes2.default.bool,
+  onClosed: _propTypes2.default.func,
+  className: _propTypes2.default.string
 };
+
 ExpandRow.defaultProps = {
@@ -38,2 +76,3 @@ children: null,
 };
-export default ExpandRow;
+
+exports.default = ExpandRow;

lib/src/row-expand/row-consumer.js

@@ -1,43 +0,76 @@
-function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+'use strict';
 
-/* eslint react/prop-types: 0 */
-import React from 'react';
-import cs from 'classnames';
-import ExpandRow from './expand-row';
-import _ from '../utils';
-import ExpansionContext from '../contexts/row-expand-context';
-export default (Component => {
-  const renderWithExpansion = (props, expandRow) => {
-    let parentClassName = '';
-    let className = '';
-    const key = props.value;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-    const expanded = _.contains(expandRow.expanded, key);
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; /* eslint react/prop-types: 0 */
 
-    const isClosing = _.contains(expandRow.isClosing, key);
 
-    const expandable = !expandRow.nonExpandable || !_.contains(expandRow.nonExpandable, key);
+var _react = require('react');
 
+var _react2 = _interopRequireDefault(_react);
+
+var _classnames = require('classnames');
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
+var _expandRow = require('./expand-row');
+
+var _expandRow2 = _interopRequireDefault(_expandRow);
+
+var _utils = require('../utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+var _rowExpandContext = require('../contexts/row-expand-context');
+
+var _rowExpandContext2 = _interopRequireDefault(_rowExpandContext);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = function (Component) {
+  var renderWithExpansion = function renderWithExpansion(props, expandRow) {
+    var parentClassName = '';
+    var className = '';
+    var key = props.value;
+
+    var expanded = _utils2.default.contains(expandRow.expanded, key);
+    var isClosing = _utils2.default.contains(expandRow.isClosing, key);
+    var expandable = !expandRow.nonExpandable || !_utils2.default.contains(expandRow.nonExpandable, key);
     if (expanded) {
-      parentClassName = _.isFunction(expandRow.parentClassName) ? expandRow.parentClassName(expanded, props.row, props.rowIndex) : expandRow.parentClassName || '';
-      className = _.isFunction(expandRow.className) ? expandRow.className(expanded, props.row, props.rowIndex) : expandRow.className || '';
+      parentClassName = _utils2.default.isFunction(expandRow.parentClassName) ? expandRow.parentClassName(expanded, props.row, props.rowIndex) : expandRow.parentClassName || '';
+
+      className = _utils2.default.isFunction(expandRow.className) ? expandRow.className(expanded, props.row, props.rowIndex) : expandRow.className || '';
     }
 
-    return [/*#__PURE__*/React.createElement(Component, _extends({}, props, {
+    return [_react2.default.createElement(Component, _extends({}, props, {
       key: key,
       expanded: expanded,
       expandable: expandable,
-      expandRow: { ...expandRow
+      expandRow: _extends({}, expandRow),
+      className: (0, _classnames2.default)(props.className, parentClassName)
+    })), expanded || isClosing ? _react2.default.createElement(
+      _expandRow2.default,
+      {
+        key: key + '-expanding',
+        colSpan: props.visibleColumnSize,
+        expanded: expanded,
+        onClosed: function onClosed() {
+          return expandRow.onClosed(key);
+        },
+        className: className
       },
-      className: cs(props.className, parentClassName)
-    })), expanded || isClosing ? /*#__PURE__*/React.createElement(ExpandRow, {
-      key: `${key}-expanding`,
-      colSpan: props.visibleColumnSize,
-      expanded: expanded,
-      onClosed: () => expandRow.onClosed(key),
-      className: className
-    }, expandRow.renderer(props.row, props.rowIndex)) : null];
+      expandRow.renderer(props.row, props.rowIndex)
+    ) : null];
   };
-
-  return props => /*#__PURE__*/React.createElement(ExpansionContext.Consumer, null, expandRow => renderWithExpansion(props, expandRow));
-});
+  return function (props) {
+    return _react2.default.createElement(
+      _rowExpandContext2.default.Consumer,
+      null,
+      function (expandRow) {
+        return renderWithExpansion(props, expandRow);
+      }
+    );
+  };
+};

lib/src/row-selection/row-consumer.js

@@ -1,34 +0,50 @@
-function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+'use strict';
 
-/* eslint react/prop-types: 0 */
-import React from 'react';
-import cs from 'classnames';
-import _ from '../utils';
-import SelectionContext from '../contexts/selection-context';
-export default (Component => {
-  const renderWithSelection = (props, selectRow) => {
-    const key = props.value;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-    const selected = _.contains(selectRow.selected, key);
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; /* eslint react/prop-types: 0 */
 
-    const selectable = !selectRow.nonSelectable || !_.contains(selectRow.nonSelectable, key);
 
-    const notSelectable = _.contains(selectRow.nonSelectable, key);
+var _react = require('react');
 
-    let {
-      style,
-      className
-    } = props;
+var _react2 = _interopRequireDefault(_react);
 
+var _classnames = require('classnames');
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
+var _utils = require('../utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+var _selectionContext = require('../contexts/selection-context');
+
+var _selectionContext2 = _interopRequireDefault(_selectionContext);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = function (Component) {
+  var renderWithSelection = function renderWithSelection(props, selectRow) {
+    var key = props.value;
+    var selected = _utils2.default.contains(selectRow.selected, key);
+    var selectable = !selectRow.nonSelectable || !_utils2.default.contains(selectRow.nonSelectable, key);
+    var notSelectable = _utils2.default.contains(selectRow.nonSelectable, key);
+
+    var style = props.style,
+        className = props.className;
+
+
     if (selected) {
-      const selectedStyle = _.isFunction(selectRow.style) ? selectRow.style(props.row, props.rowIndex) : selectRow.style;
-      const selectedClasses = _.isFunction(selectRow.classes) ? selectRow.classes(props.row, props.rowIndex) : selectRow.classes;
-      style = { ...style,
-        ...selectedStyle
-      };
-      className = cs(className, selectedClasses) || undefined;
+      var selectedStyle = _utils2.default.isFunction(selectRow.style) ? selectRow.style(props.row, props.rowIndex) : selectRow.style;
 
+      var selectedClasses = _utils2.default.isFunction(selectRow.classes) ? selectRow.classes(props.row, props.rowIndex) : selectRow.classes;
+
+      style = _extends({}, style, selectedStyle);
+      className = (0, _classnames2.default)(className, selectedClasses) || undefined;
+
       if (selectRow.bgColor) {
         style = style || {};
-        style.backgroundColor = _.isFunction(selectRow.bgColor) ? selectRow.bgColor(props.row, props.rowIndex) : selectRow.bgColor;
+        style.backgroundColor = _utils2.default.isFunction(selectRow.bgColor) ? selectRow.bgColor(props.row, props.rowIndex) : selectRow.bgColor;
       }
@@ -38,11 +54,11 @@ }
     if (notSelectable) {
-      const notSelectableStyle = _.isFunction(selectRow.nonSelectableStyle) ? selectRow.nonSelectableStyle(props.row, props.rowIndex) : selectRow.nonSelectableStyle;
-      const notSelectableClasses = _.isFunction(selectRow.nonSelectableClasses) ? selectRow.nonSelectableClasses(props.row, props.rowIndex) : selectRow.nonSelectableClasses;
-      style = { ...style,
-        ...notSelectableStyle
-      };
-      className = cs(className, notSelectableClasses) || undefined;
+      var notSelectableStyle = _utils2.default.isFunction(selectRow.nonSelectableStyle) ? selectRow.nonSelectableStyle(props.row, props.rowIndex) : selectRow.nonSelectableStyle;
+
+      var notSelectableClasses = _utils2.default.isFunction(selectRow.nonSelectableClasses) ? selectRow.nonSelectableClasses(props.row, props.rowIndex) : selectRow.nonSelectableClasses;
+
+      style = _extends({}, style, notSelectableStyle);
+      className = (0, _classnames2.default)(className, notSelectableClasses) || undefined;
     }
 
-    return /*#__PURE__*/React.createElement(Component, _extends({}, props, {
+    return _react2.default.createElement(Component, _extends({}, props, {
       style: style,
@@ -57,3 +73,9 @@ className: className,
   function withConsumer(props) {
-    return /*#__PURE__*/React.createElement(SelectionContext.Consumer, null, selectRow => renderWithSelection(props, selectRow));
+    return _react2.default.createElement(
+      _selectionContext2.default.Consumer,
+      null,
+      function (selectRow) {
+        return renderWithSelection(props, selectRow);
+      }
+    );
   }
@@ -63,2 +85,2 @@
   return withConsumer;
-});
+};

lib/src/row-selection/selection-cell.js

@@ -1,90 +0,146 @@
-function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+'use strict';
 
-/* eslint
-  react/require-default-props: 0
-  jsx-a11y/no-noninteractive-element-interactions: 0
-*/
-import React, { Component } from 'react';
-import PropTypes from 'prop-types';
-import Const from '../const';
-import _ from '../utils';
-import { BootstrapContext } from '../contexts/bootstrap';
-export default class SelectionCell extends Component {
-  static propTypes = {
-    mode: PropTypes.string.isRequired,
-    rowKey: PropTypes.any,
-    selected: PropTypes.bool,
-    onRowSelect: PropTypes.func,
-    disabled: PropTypes.bool,
-    rowIndex: PropTypes.number,
-    tabIndex: PropTypes.number,
-    clickToSelect: PropTypes.bool,
-    selectionRenderer: PropTypes.func,
-    selectColumnStyle: PropTypes.oneOfType([PropTypes.object, PropTypes.func])
-  };
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-  constructor() {
-    super();
-    this.handleClick = this.handleClick.bind(this);
-  }
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
 
-  shouldComponentUpdate(nextProps) {
-    const shouldUpdate = this.props.rowIndex !== nextProps.rowIndex || this.props.selected !== nextProps.selected || this.props.disabled !== nextProps.disabled || this.props.rowKey !== nextProps.rowKey || this.props.tabIndex !== nextProps.tabIndex || this.props.selectColumnStyle !== nextProps.selectColumnStyle;
-    return shouldUpdate;
-  }
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-  handleClick(e) {
-    const {
-      mode: inputType,
-      rowKey,
-      selected,
-      onRowSelect,
-      disabled,
-      rowIndex
-    } = this.props;
-    e.stopPropagation();
-    if (disabled) return;
-    const checked = inputType === Const.ROW_SELECT_SINGLE ? true : !selected;
-    onRowSelect(rowKey, checked, rowIndex, e);
-  }
+var _react = require('react');
 
-  render() {
-    const {
-      rowKey,
-      mode: inputType,
-      selected,
-      disabled,
-      tabIndex,
-      rowIndex,
-      selectionRenderer,
-      selectColumnStyle
-    } = this.props;
-    const attrs = {};
-    if (tabIndex !== -1) attrs.tabIndex = tabIndex;
-    attrs.style = _.isFunction(selectColumnStyle) ? selectColumnStyle({
-      checked: selected,
-      disabled,
-      rowIndex,
-      rowKey
-    }) : selectColumnStyle;
-    return /*#__PURE__*/React.createElement(BootstrapContext.Consumer, null, ({
-      bootstrap4
-    }) => /*#__PURE__*/React.createElement("td", _extends({
-      className: "selection-cell",
-      onClick: this.handleClick
-    }, attrs), selectionRenderer ? selectionRenderer({
-      mode: inputType,
-      checked: selected,
-      disabled,
-      rowIndex,
-      rowKey
-    }) : /*#__PURE__*/React.createElement("input", {
-      type: inputType,
-      checked: selected,
-      disabled: disabled,
-      className: bootstrap4 ? 'selection-input-4' : '',
-      onChange: () => {}
-    })));
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _const = require('../const');
+
+var _const2 = _interopRequireDefault(_const);
+
+var _utils = require('../utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+var _bootstrap = require('../contexts/bootstrap');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 react/require-default-props: 0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 jsx-a11y/no-noninteractive-element-interactions: 0
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               */
+
+
+var SelectionCell = function (_Component) {
+  _inherits(SelectionCell, _Component);
+
+  function SelectionCell() {
+    _classCallCheck(this, SelectionCell);
+
+    var _this = _possibleConstructorReturn(this, (SelectionCell.__proto__ || Object.getPrototypeOf(SelectionCell)).call(this));
+
+    _this.handleClick = _this.handleClick.bind(_this);
+    return _this;
   }
 
-}
+  _createClass(SelectionCell, [{
+    key: 'shouldComponentUpdate',
+    value: function shouldComponentUpdate(nextProps) {
+      var shouldUpdate = this.props.rowIndex !== nextProps.rowIndex || this.props.selected !== nextProps.selected || this.props.disabled !== nextProps.disabled || this.props.rowKey !== nextProps.rowKey || this.props.tabIndex !== nextProps.tabIndex || this.props.selectColumnStyle !== nextProps.selectColumnStyle;
+
+      return shouldUpdate;
+    }
+  }, {
+    key: 'handleClick',
+    value: function handleClick(e) {
+      var _props = this.props,
+          inputType = _props.mode,
+          rowKey = _props.rowKey,
+          selected = _props.selected,
+          onRowSelect = _props.onRowSelect,
+          disabled = _props.disabled,
+          rowIndex = _props.rowIndex;
+
+      e.stopPropagation();
+      if (disabled) return;
+
+      var checked = inputType === _const2.default.ROW_SELECT_SINGLE ? true : !selected;
+
+      onRowSelect(rowKey, checked, rowIndex, e);
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _this2 = this;
+
+      var _props2 = this.props,
+          rowKey = _props2.rowKey,
+          inputType = _props2.mode,
+          selected = _props2.selected,
+          disabled = _props2.disabled,
+          tabIndex = _props2.tabIndex,
+          rowIndex = _props2.rowIndex,
+          selectionRenderer = _props2.selectionRenderer,
+          selectColumnStyle = _props2.selectColumnStyle;
+
+
+      var attrs = {};
+      if (tabIndex !== -1) attrs.tabIndex = tabIndex;
+
+      attrs.style = _utils2.default.isFunction(selectColumnStyle) ? selectColumnStyle({
+        checked: selected,
+        disabled: disabled,
+        rowIndex: rowIndex,
+        rowKey: rowKey
+      }) : selectColumnStyle;
+
+      return _react2.default.createElement(
+        _bootstrap.BootstrapContext.Consumer,
+        null,
+        function (_ref) {
+          var bootstrap4 = _ref.bootstrap4;
+          return _react2.default.createElement(
+            'td',
+            _extends({ className: 'selection-cell', onClick: _this2.handleClick }, attrs),
+            selectionRenderer ? selectionRenderer({
+              mode: inputType,
+              checked: selected,
+              disabled: disabled,
+              rowIndex: rowIndex,
+              rowKey: rowKey
+            }) : _react2.default.createElement('input', {
+              type: inputType,
+              checked: selected,
+              disabled: disabled,
+              className: bootstrap4 ? 'selection-input-4' : '',
+              onChange: function onChange() {}
+            })
+          );
+        }
+      );
+    }
+  }]);
+
+  return SelectionCell;
+}(_react.Component);
+
+SelectionCell.propTypes = {
+  mode: _propTypes2.default.string.isRequired,
+  rowKey: _propTypes2.default.any,
+  selected: _propTypes2.default.bool,
+  onRowSelect: _propTypes2.default.func,
+  disabled: _propTypes2.default.bool,
+  rowIndex: _propTypes2.default.number,
+  tabIndex: _propTypes2.default.number,
+  clickToSelect: _propTypes2.default.bool,
+  selectionRenderer: _propTypes2.default.func,
+  selectColumnStyle: _propTypes2.default.oneOfType([_propTypes2.default.object, _propTypes2.default.func])
+};
+exports.default = SelectionCell;

lib/src/row-selection/selection-header-cell-consumer.js

@@ -1,3 +0,27 @@
-import React from 'react';
-import SelectionContext from '../contexts/selection-context';
-export default (Component => () => /*#__PURE__*/React.createElement(SelectionContext.Consumer, null, selectRow => /*#__PURE__*/React.createElement(Component, selectRow)));
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _selectionContext = require('../contexts/selection-context');
+
+var _selectionContext2 = _interopRequireDefault(_selectionContext);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.default = function (Component) {
+  return function () {
+    return _react2.default.createElement(
+      _selectionContext2.default.Consumer,
+      null,
+      function (selectRow) {
+        return _react2.default.createElement(Component, selectRow);
+      }
+    );
+  };
+};

lib/src/row-selection/selection-header-cell.js

@@ -1,41 +0,72 @@
-function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+'use strict';
 
-/* eslint react/require-default-props: 0 */
-import React, { Component } from 'react';
-import PropTypes from 'prop-types';
-import Const from '../const';
-import { BootstrapContext } from '../contexts/bootstrap';
-import _ from '../utils';
-export const CheckBox = ({
-  className,
-  checked,
-  indeterminate
-}) => /*#__PURE__*/React.createElement("input", {
-  type: "checkbox",
-  checked: checked,
-  className: className,
-  ref: input => {
-    if (input) input.indeterminate = indeterminate; // eslint-disable-line no-param-reassign
-  },
-  onChange: () => {}
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
+exports.CheckBox = undefined;
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _const = require('../const');
+
+var _const2 = _interopRequireDefault(_const);
+
+var _bootstrap = require('../contexts/bootstrap');
+
+var _utils = require('../utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint react/require-default-props: 0 */
+
+
+var CheckBox = exports.CheckBox = function CheckBox(_ref) {
+  var className = _ref.className,
+      checked = _ref.checked,
+      indeterminate = _ref.indeterminate;
+  return _react2.default.createElement('input', {
+    type: 'checkbox',
+    checked: checked,
+    className: className,
+    ref: function ref(input) {
+      if (input) input.indeterminate = indeterminate; // eslint-disable-line no-param-reassign
+    },
+    onChange: function onChange() {}
+  });
+};
+
 CheckBox.propTypes = {
-  checked: PropTypes.bool.isRequired,
-  indeterminate: PropTypes.bool.isRequired,
-  className: PropTypes.string
+  checked: _propTypes2.default.bool.isRequired,
+  indeterminate: _propTypes2.default.bool.isRequired,
+  className: _propTypes2.default.string
 };
-export default class SelectionHeaderCell extends Component {
-  static propTypes = {
-    mode: PropTypes.string.isRequired,
-    checkedStatus: PropTypes.string,
-    onAllRowsSelect: PropTypes.func,
-    hideSelectAll: PropTypes.bool,
-    selectionHeaderRenderer: PropTypes.func,
-    headerColumnStyle: PropTypes.oneOfType([PropTypes.object, PropTypes.func])
-  };
 
-  constructor() {
-    super();
-    this.handleCheckBoxClick = this.handleCheckBoxClick.bind(this);
+var SelectionHeaderCell = function (_Component) {
+  _inherits(SelectionHeaderCell, _Component);
+
+  function SelectionHeaderCell() {
+    _classCallCheck(this, SelectionHeaderCell);
+
+    var _this = _possibleConstructorReturn(this, (SelectionHeaderCell.__proto__ || Object.getPrototypeOf(SelectionHeaderCell)).call(this));
+
+    _this.handleCheckBoxClick = _this.handleCheckBoxClick.bind(_this);
+    return _this;
   }
+
   /**
@@ -48,77 +79,97 @@ * avoid updating if button is
 
-  shouldComponentUpdate(nextProps) {
-    const {
-      ROW_SELECT_SINGLE
-    } = Const;
-    const {
-      mode,
-      checkedStatus
-    } = this.props;
-    if (mode === ROW_SELECT_SINGLE) return false;
-    return nextProps.checkedStatus !== checkedStatus;
-  }
+  _createClass(SelectionHeaderCell, [{
+    key: 'shouldComponentUpdate',
+    value: function shouldComponentUpdate(nextProps) {
+      var ROW_SELECT_SINGLE = _const2.default.ROW_SELECT_SINGLE;
+      var _props = this.props,
+          mode = _props.mode,
+          checkedStatus = _props.checkedStatus;
 
-  handleCheckBoxClick(e) {
-    const {
-      onAllRowsSelect,
-      checkedStatus
-    } = this.props;
-    const isUnSelect = checkedStatus === Const.CHECKBOX_STATUS_CHECKED || checkedStatus === Const.CHECKBOX_STATUS_INDETERMINATE;
-    onAllRowsSelect(e, isUnSelect);
-  }
 
-  render() {
-    const {
-      CHECKBOX_STATUS_CHECKED,
-      CHECKBOX_STATUS_INDETERMINATE,
-      ROW_SELECT_MULTIPLE
-    } = Const;
-    const {
-      mode,
-      checkedStatus,
-      selectionHeaderRenderer,
-      hideSelectAll,
-      headerColumnStyle
-    } = this.props;
+      if (mode === ROW_SELECT_SINGLE) return false;
 
-    if (hideSelectAll) {
-      return /*#__PURE__*/React.createElement("th", {
-        "data-row-selection": true
-      });
+      return nextProps.checkedStatus !== checkedStatus;
     }
+  }, {
+    key: 'handleCheckBoxClick',
+    value: function handleCheckBoxClick(e) {
+      var _props2 = this.props,
+          onAllRowsSelect = _props2.onAllRowsSelect,
+          checkedStatus = _props2.checkedStatus;
 
-    const checked = checkedStatus === CHECKBOX_STATUS_CHECKED;
-    const indeterminate = checkedStatus === CHECKBOX_STATUS_INDETERMINATE;
-    const attrs = {};
-    let content;
+      var isUnSelect = checkedStatus === _const2.default.CHECKBOX_STATUS_CHECKED || checkedStatus === _const2.default.CHECKBOX_STATUS_INDETERMINATE;
 
-    if (selectionHeaderRenderer || mode === ROW_SELECT_MULTIPLE) {
-      attrs.onClick = this.handleCheckBoxClick;
+      onAllRowsSelect(e, isUnSelect);
     }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _this2 = this;
 
-    attrs.style = _.isFunction(headerColumnStyle) ? headerColumnStyle(checkedStatus) : headerColumnStyle;
-    return /*#__PURE__*/React.createElement(BootstrapContext.Consumer, null, ({
-      bootstrap4
-    }) => {
-      if (selectionHeaderRenderer) {
-        content = selectionHeaderRenderer({
-          mode,
-          checked,
-          indeterminate
-        });
-      } else if (mode === ROW_SELECT_MULTIPLE) {
-        content = /*#__PURE__*/React.createElement(CheckBox, _extends({}, this.props, {
-          checked: checked,
-          className: bootstrap4 ? 'selection-input-4' : '',
-          indeterminate: indeterminate
-        }));
+      var CHECKBOX_STATUS_CHECKED = _const2.default.CHECKBOX_STATUS_CHECKED,
+          CHECKBOX_STATUS_INDETERMINATE = _const2.default.CHECKBOX_STATUS_INDETERMINATE,
+          ROW_SELECT_MULTIPLE = _const2.default.ROW_SELECT_MULTIPLE;
+      var _props3 = this.props,
+          mode = _props3.mode,
+          checkedStatus = _props3.checkedStatus,
+          selectionHeaderRenderer = _props3.selectionHeaderRenderer,
+          hideSelectAll = _props3.hideSelectAll,
+          headerColumnStyle = _props3.headerColumnStyle;
+
+      if (hideSelectAll) {
+        return _react2.default.createElement('th', { 'data-row-selection': true });
       }
 
-      return /*#__PURE__*/React.createElement("th", _extends({
-        className: "selection-cell-header",
-        "data-row-selection": true
-      }, attrs), content);
-    });
-  }
+      var checked = checkedStatus === CHECKBOX_STATUS_CHECKED;
 
-}
+      var indeterminate = checkedStatus === CHECKBOX_STATUS_INDETERMINATE;
+
+      var attrs = {};
+      var content = void 0;
+      if (selectionHeaderRenderer || mode === ROW_SELECT_MULTIPLE) {
+        attrs.onClick = this.handleCheckBoxClick;
+      }
+
+      attrs.style = _utils2.default.isFunction(headerColumnStyle) ? headerColumnStyle(checkedStatus) : headerColumnStyle;
+
+      return _react2.default.createElement(
+        _bootstrap.BootstrapContext.Consumer,
+        null,
+        function (_ref2) {
+          var bootstrap4 = _ref2.bootstrap4;
+
+          if (selectionHeaderRenderer) {
+            content = selectionHeaderRenderer({
+              mode: mode,
+              checked: checked,
+              indeterminate: indeterminate
+            });
+          } else if (mode === ROW_SELECT_MULTIPLE) {
+            content = _react2.default.createElement(CheckBox, _extends({}, _this2.props, {
+              checked: checked,
+              className: bootstrap4 ? 'selection-input-4' : '',
+              indeterminate: indeterminate
+            }));
+          }
+          return _react2.default.createElement(
+            'th',
+            _extends({ className: 'selection-cell-header', 'data-row-selection': true }, attrs),
+            content
+          );
+        }
+      );
+    }
+  }]);
+
+  return SelectionHeaderCell;
+}(_react.Component);
+
+SelectionHeaderCell.propTypes = {
+  mode: _propTypes2.default.string.isRequired,
+  checkedStatus: _propTypes2.default.string,
+  onAllRowsSelect: _propTypes2.default.func,
+  hideSelectAll: _propTypes2.default.bool,
+  selectionHeaderRenderer: _propTypes2.default.func,
+  headerColumnStyle: _propTypes2.default.oneOfType([_propTypes2.default.object, _propTypes2.default.func])
+};
+exports.default = SelectionHeaderCell;

lib/src/row/aggregate-row.js

@@ -1,137 +0,192 @@
-function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+'use strict';
 
-/* eslint class-methods-use-this: 0 */
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _utils = require('../utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+var _expandCell = require('../row-expand/expand-cell');
+
+var _expandCell2 = _interopRequireDefault(_expandCell);
+
+var _selectionCell = require('../row-selection/selection-cell');
+
+var _selectionCell2 = _interopRequireDefault(_selectionCell);
+
+var _shouldUpdater2 = require('./should-updater');
+
+var _shouldUpdater3 = _interopRequireDefault(_shouldUpdater2);
+
+var _eventDelegater = require('./event-delegater');
+
+var _eventDelegater2 = _interopRequireDefault(_eventDelegater);
+
+var _rowPureContent = require('./row-pure-content');
+
+var _rowPureContent2 = _interopRequireDefault(_rowPureContent);
+
+var _const = require('../const');
+
+var _const2 = _interopRequireDefault(_const);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint class-methods-use-this: 0 */
 /* eslint react/prop-types: 0 */
-
 /* eslint no-plusplus: 0 */
-import React from 'react';
-import PropTypes from 'prop-types';
-import _ from '../utils';
-import ExpandCell from '../row-expand/expand-cell';
-import SelectionCell from '../row-selection/selection-cell';
-import shouldUpdater from './should-updater';
-import eventDelegater from './event-delegater';
-import RowPureContent from './row-pure-content';
-import Const from '../const';
-export default class RowAggregator extends shouldUpdater(eventDelegater(React.Component)) {
-  static propTypes = {
-    attrs: PropTypes.object,
-    style: PropTypes.object
-  };
-  static defaultProps = {
-    attrs: {},
-    style: {}
-  };
 
-  constructor(props) {
-    super(props);
-    this.clickNum = 0;
-    this.shouldUpdateRowContent = false;
-    this.createClickEventHandler = this.createClickEventHandler.bind(this);
-  }
 
-  shouldComponentUpdate(nextProps) {
-    if (this.props.selected !== nextProps.selected || this.props.expanded !== nextProps.expanded || this.props.expandable !== nextProps.expandable || this.props.selectable !== nextProps.selectable || this.props.selectRow.hideSelectColumn !== nextProps.selectRow.hideSelectColumn || this.shouldUpdatedBySelfProps(nextProps)) {
-      this.shouldUpdateRowContent = this.shouldRowContentUpdate(nextProps);
-      return true;
-    }
+var RowAggregator = function (_shouldUpdater) {
+  _inherits(RowAggregator, _shouldUpdater);
 
-    this.shouldUpdateRowContent = this.shouldRowContentUpdate(nextProps);
-    return this.shouldUpdateRowContent;
-  }
+  function RowAggregator(props) {
+    _classCallCheck(this, RowAggregator);
 
-  isRenderFunctionColumnInLeft(position = Const.INDICATOR_POSITION_LEFT) {
-    return position === Const.INDICATOR_POSITION_LEFT;
+    var _this = _possibleConstructorReturn(this, (RowAggregator.__proto__ || Object.getPrototypeOf(RowAggregator)).call(this, props));
+
+    _this.clickNum = 0;
+    _this.shouldUpdateRowContent = false;
+    _this.createClickEventHandler = _this.createClickEventHandler.bind(_this);
+    return _this;
   }
 
-  render() {
-    const {
-      row,
-      columns,
-      keyField,
-      rowIndex,
-      style,
-      className,
-      attrs,
-      selectRow,
-      expandRow,
-      expanded,
-      expandable,
-      selected,
-      selectable,
-      visibleColumnSize,
-      tabIndexCell,
-      ...rest
-    } = this.props;
+  _createClass(RowAggregator, [{
+    key: 'shouldComponentUpdate',
+    value: function shouldComponentUpdate(nextProps) {
+      if (this.props.selected !== nextProps.selected || this.props.expanded !== nextProps.expanded || this.props.expandable !== nextProps.expandable || this.props.selectable !== nextProps.selectable || this.props.selectRow.hideSelectColumn !== nextProps.selectRow.hideSelectColumn || this.shouldUpdatedBySelfProps(nextProps)) {
+        this.shouldUpdateRowContent = this.shouldRowContentUpdate(nextProps);
+        return true;
+      }
+      this.shouldUpdateRowContent = this.shouldRowContentUpdate(nextProps);
 
-    const key = _.get(row, keyField);
+      return this.shouldUpdateRowContent;
+    }
+  }, {
+    key: 'isRenderFunctionColumnInLeft',
+    value: function isRenderFunctionColumnInLeft() {
+      var position = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _const2.default.INDICATOR_POSITION_LEFT;
 
-    const {
-      hideSelectColumn,
-      selectColumnPosition,
-      clickToSelect
-    } = selectRow;
-    const {
-      showExpandColumn,
-      expandColumnPosition
-    } = expandRow;
-    const newAttrs = this.delegate({ ...attrs
-    });
-
-    if (clickToSelect || !!expandRow.renderer) {
-      newAttrs.onClick = this.createClickEventHandler(newAttrs.onClick);
+      return position === _const2.default.INDICATOR_POSITION_LEFT;
     }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          row = _props.row,
+          columns = _props.columns,
+          keyField = _props.keyField,
+          rowIndex = _props.rowIndex,
+          style = _props.style,
+          className = _props.className,
+          attrs = _props.attrs,
+          selectRow = _props.selectRow,
+          expandRow = _props.expandRow,
+          expanded = _props.expanded,
+          expandable = _props.expandable,
+          selected = _props.selected,
+          selectable = _props.selectable,
+          visibleColumnSize = _props.visibleColumnSize,
+          tabIndexCell = _props.tabIndexCell,
+          rest = _objectWithoutProperties(_props, ['row', 'columns', 'keyField', 'rowIndex', 'style', 'className', 'attrs', 'selectRow', 'expandRow', 'expanded', 'expandable', 'selected', 'selectable', 'visibleColumnSize', 'tabIndexCell']);
 
-    let tabIndexStart = rowIndex * visibleColumnSize + 1;
-    const childrens = [/*#__PURE__*/React.createElement(RowPureContent, _extends({
-      key: "row",
-      row: row,
-      columns: columns,
-      keyField: keyField,
-      rowIndex: rowIndex,
-      shouldUpdate: this.shouldUpdateRowContent,
-      tabIndexStart: tabIndexCell ? tabIndexStart : -1
-    }, rest))];
+      var key = _utils2.default.get(row, keyField);
+      var hideSelectColumn = selectRow.hideSelectColumn,
+          selectColumnPosition = selectRow.selectColumnPosition,
+          clickToSelect = selectRow.clickToSelect;
+      var showExpandColumn = expandRow.showExpandColumn,
+          expandColumnPosition = expandRow.expandColumnPosition;
 
-    if (!hideSelectColumn) {
-      const selectCell = /*#__PURE__*/React.createElement(SelectionCell, _extends({}, selectRow, {
-        key: "selection-cell",
-        rowKey: key,
-        rowIndex: rowIndex,
-        selected: selected,
-        disabled: !selectable,
-        tabIndex: tabIndexCell ? tabIndexStart++ : -1
-      }));
 
-      if (this.isRenderFunctionColumnInLeft(selectColumnPosition)) {
-        childrens.unshift(selectCell);
-      } else {
-        childrens.push(selectCell);
+      var newAttrs = this.delegate(_extends({}, attrs));
+      if (clickToSelect || !!expandRow.renderer) {
+        newAttrs.onClick = this.createClickEventHandler(newAttrs.onClick);
       }
-    }
 
-    if (showExpandColumn) {
-      const expandCell = /*#__PURE__*/React.createElement(ExpandCell, _extends({}, expandRow, {
-        key: "expand-cell",
-        rowKey: key,
+      var tabIndexStart = rowIndex * visibleColumnSize + 1;
+
+      var childrens = [_react2.default.createElement(_rowPureContent2.default, _extends({
+        key: 'row',
+        row: row,
+        columns: columns,
+        keyField: keyField,
         rowIndex: rowIndex,
-        expanded: expanded,
-        expandable: expandable,
-        tabIndex: tabIndexCell ? tabIndexStart++ : -1
-      }));
+        shouldUpdate: this.shouldUpdateRowContent,
+        tabIndexStart: tabIndexCell ? tabIndexStart : -1
+      }, rest))];
 
-      if (this.isRenderFunctionColumnInLeft(expandColumnPosition)) {
-        childrens.unshift(expandCell);
-      } else {
-        childrens.push(expandCell);
+      if (!hideSelectColumn) {
+        var selectCell = _react2.default.createElement(_selectionCell2.default, _extends({}, selectRow, {
+          key: 'selection-cell',
+          rowKey: key,
+          rowIndex: rowIndex,
+          selected: selected,
+          disabled: !selectable,
+          tabIndex: tabIndexCell ? tabIndexStart++ : -1
+        }));
+        if (this.isRenderFunctionColumnInLeft(selectColumnPosition)) {
+          childrens.unshift(selectCell);
+        } else {
+          childrens.push(selectCell);
+        }
       }
+
+      if (showExpandColumn) {
+        var expandCell = _react2.default.createElement(_expandCell2.default, _extends({}, expandRow, {
+          key: 'expand-cell',
+          rowKey: key,
+          rowIndex: rowIndex,
+          expanded: expanded,
+          expandable: expandable,
+          tabIndex: tabIndexCell ? tabIndexStart++ : -1
+        }));
+        if (this.isRenderFunctionColumnInLeft(expandColumnPosition)) {
+          childrens.unshift(expandCell);
+        } else {
+          childrens.push(expandCell);
+        }
+      }
+
+      return _react2.default.createElement(
+        'tr',
+        _extends({
+          style: style,
+          className: className
+        }, newAttrs),
+        childrens
+      );
     }
+  }]);
 
-    return /*#__PURE__*/React.createElement("tr", _extends({
-      style: style,
-      className: className
-    }, newAttrs), childrens);
-  }
+  return RowAggregator;
+}((0, _shouldUpdater3.default)((0, _eventDelegater2.default)(_react2.default.Component)));
 
-}
+RowAggregator.propTypes = {
+  attrs: _propTypes2.default.object,
+  style: _propTypes2.default.object
+};
+RowAggregator.defaultProps = {
+  attrs: {},
+  style: {}
+};
+exports.default = RowAggregator;

lib/src/row/event-delegater.js

@@ -1,82 +0,122 @@
-import _ from '../utils';
-import Const from '../const';
-const events = ['onClick', 'onDoubleClick', 'onMouseEnter', 'onMouseLeave', 'onContextMenu', 'onAuxClick'];
-export default (ExtendBase => class RowEventDelegater extends ExtendBase {
-  constructor(props) {
-    super(props);
-    this.clickNum = 0;
-    this.createDefaultEventHandler = this.createDefaultEventHandler.bind(this);
-    this.createClickEventHandler = this.createClickEventHandler.bind(this);
-  }
+'use strict';
 
-  createClickEventHandler(cb) {
-    return e => {
-      const {
-        row,
-        selected,
-        keyField,
-        selectable,
-        expandable,
-        rowIndex,
-        expanded,
-        expandRow,
-        selectRow,
-        DELAY_FOR_DBCLICK
-      } = this.props;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-      const clickFn = () => {
-        if (cb) {
-          cb(e, row, rowIndex);
-        }
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
 
-        const key = _.get(row, keyField);
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-        if (expandRow && expandable && !expandRow.expandByColumnOnly) {
-          if (selectRow.mode !== Const.ROW_SELECT_DISABLED && selectRow.clickToExpand || selectRow.mode === Const.ROW_SELECT_DISABLED) {
-            expandRow.onRowExpand(key, !expanded, rowIndex, e);
-          }
-        }
+var _utils = require('../utils');
 
-        if (selectRow.clickToSelect && selectable) {
-          selectRow.onRowSelect(key, !selected, rowIndex, e);
-        }
-      };
+var _utils2 = _interopRequireDefault(_utils);
 
-      if (DELAY_FOR_DBCLICK) {
-        this.clickNum += 1;
+var _const = require('../const');
 
-        _.debounce(() => {
-          if (this.clickNum === 1) {
+var _const2 = _interopRequireDefault(_const);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var events = ['onClick', 'onDoubleClick', 'onMouseEnter', 'onMouseLeave', 'onContextMenu', 'onAuxClick'];
+
+exports.default = function (ExtendBase) {
+  return function (_ExtendBase) {
+    _inherits(RowEventDelegater, _ExtendBase);
+
+    function RowEventDelegater(props) {
+      _classCallCheck(this, RowEventDelegater);
+
+      var _this = _possibleConstructorReturn(this, (RowEventDelegater.__proto__ || Object.getPrototypeOf(RowEventDelegater)).call(this, props));
+
+      _this.clickNum = 0;
+      _this.createDefaultEventHandler = _this.createDefaultEventHandler.bind(_this);
+      _this.createClickEventHandler = _this.createClickEventHandler.bind(_this);
+      return _this;
+    }
+
+    _createClass(RowEventDelegater, [{
+      key: 'createClickEventHandler',
+      value: function createClickEventHandler(cb) {
+        var _this2 = this;
+
+        return function (e) {
+          var _props = _this2.props,
+              row = _props.row,
+              selected = _props.selected,
+              keyField = _props.keyField,
+              selectable = _props.selectable,
+              expandable = _props.expandable,
+              rowIndex = _props.rowIndex,
+              expanded = _props.expanded,
+              expandRow = _props.expandRow,
+              selectRow = _props.selectRow,
+              DELAY_FOR_DBCLICK = _props.DELAY_FOR_DBCLICK;
+
+          var clickFn = function clickFn() {
+            if (cb) {
+              cb(e, row, rowIndex);
+            }
+            var key = _utils2.default.get(row, keyField);
+            if (expandRow && expandable && !expandRow.expandByColumnOnly) {
+              if (selectRow.mode !== _const2.default.ROW_SELECT_DISABLED && selectRow.clickToExpand || selectRow.mode === _const2.default.ROW_SELECT_DISABLED) {
+                expandRow.onRowExpand(key, !expanded, rowIndex, e);
+              }
+            }
+            if (selectRow.clickToSelect && selectable) {
+              selectRow.onRowSelect(key, !selected, rowIndex, e);
+            }
+          };
+
+          if (DELAY_FOR_DBCLICK) {
+            _this2.clickNum += 1;
+            _utils2.default.debounce(function () {
+              if (_this2.clickNum === 1) {
+                clickFn();
+              }
+              _this2.clickNum = 0;
+            }, DELAY_FOR_DBCLICK)();
+          } else {
             clickFn();
           }
+        };
+      }
+    }, {
+      key: 'createDefaultEventHandler',
+      value: function createDefaultEventHandler(cb) {
+        var _this3 = this;
 
-          this.clickNum = 0;
-        }, DELAY_FOR_DBCLICK)();
-      } else {
-        clickFn();
+        return function (e) {
+          var _props2 = _this3.props,
+              row = _props2.row,
+              rowIndex = _props2.rowIndex;
+
+          cb(e, row, rowIndex);
+        };
       }
-    };
-  }
+    }, {
+      key: 'delegate',
+      value: function delegate() {
+        var _this4 = this;
 
-  createDefaultEventHandler(cb) {
-    return e => {
-      const {
-        row,
-        rowIndex
-      } = this.props;
-      cb(e, row, rowIndex);
-    };
-  }
+        var attrs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
-  delegate(attrs = {}) {
-    const newAttrs = { ...attrs
-    };
-    Object.keys(attrs).forEach(attr => {
-      if (_.contains(events, attr)) {
-        newAttrs[attr] = this.createDefaultEventHandler(attrs[attr]);
+        var newAttrs = _extends({}, attrs);
+        Object.keys(attrs).forEach(function (attr) {
+          if (_utils2.default.contains(events, attr)) {
+            newAttrs[attr] = _this4.createDefaultEventHandler(attrs[attr]);
+          }
+        });
+        return newAttrs;
       }
-    });
-    return newAttrs;
-  }
+    }]);
 
-});
+    return RowEventDelegater;
+  }(ExtendBase);
+};

lib/src/row/row-pure-content.js

@@ -1,114 +0,151 @@
-function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+'use strict';
 
-/* eslint react/prop-types: 0 */
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _utils = require('../utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+var _cell = require('../cell');
+
+var _cell2 = _interopRequireDefault(_cell);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint react/prop-types: 0 */
 /* eslint react/no-array-index-key: 0 */
-
 /* eslint no-plusplus: 0 */
-import React from 'react';
-import _ from '../utils';
-import Cell from '../cell';
-export default class RowPureContent extends React.Component {
-  shouldComponentUpdate(nextProps) {
-    if (typeof nextProps.shouldUpdate !== 'undefined') {
-      return nextProps.shouldUpdate;
-    }
 
-    return true;
+
+var RowPureContent = function (_React$Component) {
+  _inherits(RowPureContent, _React$Component);
+
+  function RowPureContent() {
+    _classCallCheck(this, RowPureContent);
+
+    return _possibleConstructorReturn(this, (RowPureContent.__proto__ || Object.getPrototypeOf(RowPureContent)).apply(this, arguments));
   }
 
-  render() {
-    const {
-      row,
-      keyField,
-      columns,
-      rowIndex,
-      editable,
-      editingRowIdx,
-      editingColIdx,
-      onStart,
-      clickToEdit,
-      dbclickToEdit,
-      EditingCellComponent,
-      tabIndexStart
-    } = this.props;
-    let tabIndex = tabIndexStart;
-    return columns.map((column, index) => {
-      const {
-        dataField
-      } = column;
+  _createClass(RowPureContent, [{
+    key: 'shouldComponentUpdate',
+    value: function shouldComponentUpdate(nextProps) {
+      if (typeof nextProps.shouldUpdate !== 'undefined') {
+        return nextProps.shouldUpdate;
+      }
+      return true;
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          row = _props.row,
+          keyField = _props.keyField,
+          columns = _props.columns,
+          rowIndex = _props.rowIndex,
+          editable = _props.editable,
+          editingRowIdx = _props.editingRowIdx,
+          editingColIdx = _props.editingColIdx,
+          onStart = _props.onStart,
+          clickToEdit = _props.clickToEdit,
+          dbclickToEdit = _props.dbclickToEdit,
+          EditingCellComponent = _props.EditingCellComponent,
+          tabIndexStart = _props.tabIndexStart;
 
-      const content = _.get(row, dataField);
 
-      if (rowIndex === editingRowIdx && index === editingColIdx) {
-        return /*#__PURE__*/React.createElement(EditingCellComponent, {
-          key: `${content}-${index}-editing`,
-          row: row,
-          rowIndex: rowIndex,
-          column: column,
-          columnIndex: index
-        });
-      } // render cell
+      var tabIndex = tabIndexStart;
 
+      return columns.map(function (column, index) {
+        var dataField = column.dataField;
 
-      let cellTitle;
-      let cellStyle = {};
-      let cellAttrs = { ...(_.isFunction(column.attrs) ? column.attrs(content, row, rowIndex, index) : column.attrs)
-      };
+        var content = _utils2.default.get(row, dataField);
+        if (rowIndex === editingRowIdx && index === editingColIdx) {
+          return _react2.default.createElement(EditingCellComponent, {
+            key: content + '-' + index + '-editing',
+            row: row,
+            rowIndex: rowIndex,
+            column: column,
+            columnIndex: index
+          });
+        }
+        // render cell
+        var cellTitle = void 0;
+        var cellStyle = {};
+        var cellAttrs = _extends({}, _utils2.default.isFunction(column.attrs) ? column.attrs(content, row, rowIndex, index) : column.attrs);
 
-      if (column.events) {
-        const events = Object.assign({}, column.events);
-        Object.keys(Object.assign({}, column.events)).forEach(key => {
-          const originFn = events[key];
+        if (column.events) {
+          var events = Object.assign({}, column.events);
+          Object.keys(Object.assign({}, column.events)).forEach(function (key) {
+            var originFn = events[key];
+            events[key] = function () {
+              for (var _len = arguments.length, rest = Array(_len), _key = 0; _key < _len; _key++) {
+                rest[_key] = arguments[_key];
+              }
 
-          events[key] = (...rest) => originFn(...rest, row, rowIndex);
-        });
-        cellAttrs = { ...cellAttrs,
-          ...events
-        };
-      }
+              return originFn.apply(undefined, rest.concat([row, rowIndex]));
+            };
+          });
+          cellAttrs = _extends({}, cellAttrs, events);
+        }
 
-      const cellClasses = _.isFunction(column.classes) ? column.classes(content, row, rowIndex, index) : column.classes;
+        var cellClasses = _utils2.default.isFunction(column.classes) ? column.classes(content, row, rowIndex, index) : column.classes;
 
-      if (column.style) {
-        cellStyle = _.isFunction(column.style) ? column.style(content, row, rowIndex, index) : column.style;
-        cellStyle = Object.assign({}, cellStyle) || {};
-      }
+        if (column.style) {
+          cellStyle = _utils2.default.isFunction(column.style) ? column.style(content, row, rowIndex, index) : column.style;
+          cellStyle = Object.assign({}, cellStyle) || {};
+        }
 
-      if (column.title) {
-        cellTitle = _.isFunction(column.title) ? column.title(content, row, rowIndex, index) : content;
-        cellAttrs.title = cellTitle;
-      }
+        if (column.title) {
+          cellTitle = _utils2.default.isFunction(column.title) ? column.title(content, row, rowIndex, index) : content;
+          cellAttrs.title = cellTitle;
+        }
 
-      if (column.align) {
-        cellStyle.textAlign = _.isFunction(column.align) ? column.align(content, row, rowIndex, index) : column.align;
-      }
+        if (column.align) {
+          cellStyle.textAlign = _utils2.default.isFunction(column.align) ? column.align(content, row, rowIndex, index) : column.align;
+        }
 
-      if (cellClasses) cellAttrs.className = cellClasses;
-      if (!_.isEmptyObject(cellStyle)) cellAttrs.style = cellStyle;
-      let editableCell = _.isDefined(column.editable) ? column.editable : true;
-      if (column.dataField === keyField || !editable) editableCell = false;
+        if (cellClasses) cellAttrs.className = cellClasses;
+        if (!_utils2.default.isEmptyObject(cellStyle)) cellAttrs.style = cellStyle;
 
-      if (_.isFunction(column.editable)) {
-        editableCell = column.editable(content, row, rowIndex, index);
-      }
+        var editableCell = _utils2.default.isDefined(column.editable) ? column.editable : true;
+        if (column.dataField === keyField || !editable) editableCell = false;
+        if (_utils2.default.isFunction(column.editable)) {
+          editableCell = column.editable(content, row, rowIndex, index);
+        }
 
-      if (tabIndexStart !== -1) {
-        cellAttrs.tabIndex = tabIndex++;
-      }
+        if (tabIndexStart !== -1) {
+          cellAttrs.tabIndex = tabIndex++;
+        }
 
-      return /*#__PURE__*/React.createElement(Cell, _extends({
-        key: `${content}-${index}`,
-        row: row,
-        editable: editableCell,
-        rowIndex: rowIndex,
-        columnIndex: index,
-        column: column,
-        onStart: onStart,
-        clickToEdit: clickToEdit,
-        dbclickToEdit: dbclickToEdit
-      }, cellAttrs));
-    });
-  }
+        return _react2.default.createElement(_cell2.default, _extends({
+          key: content + '-' + index,
+          row: row,
+          editable: editableCell,
+          rowIndex: rowIndex,
+          columnIndex: index,
+          column: column,
+          onStart: onStart,
+          clickToEdit: clickToEdit,
+          dbclickToEdit: dbclickToEdit
+        }, cellAttrs));
+      });
+    }
+  }]);
 
-}
+  return RowPureContent;
+}(_react2.default.Component);
+
+exports.default = RowPureContent;

lib/src/row/row-section.js

@@ -1,17 +0,40 @@
-import React from 'react';
-import PropTypes from 'prop-types';
+'use strict';
 
-const RowSection = ({
-  content,
-  colSpan
-}) => /*#__PURE__*/React.createElement("tr", null, /*#__PURE__*/React.createElement("td", {
-  "data-toggle": "collapse",
-  colSpan: colSpan,
-  className: "react-bs-table-no-data"
-}, content));
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var RowSection = function RowSection(_ref) {
+  var content = _ref.content,
+      colSpan = _ref.colSpan;
+  return _react2.default.createElement(
+    'tr',
+    null,
+    _react2.default.createElement(
+      'td',
+      {
+        'data-toggle': 'collapse',
+        colSpan: colSpan,
+        className: 'react-bs-table-no-data'
+      },
+      content
+    )
+  );
+};
+
 RowSection.propTypes = {
-  content: PropTypes.any,
-  colSpan: PropTypes.number
+  content: _propTypes2.default.any,
+  colSpan: _propTypes2.default.number
 };
+
 RowSection.defaultProps = {
@@ -21,2 +44,3 @@ content: null,
 };
-export default RowSection;
+
+exports.default = RowSection;

lib/src/row/row-template.js

@@ -1,28 +0,43 @@
-/* eslint react/require-default-props: 0 */
-import React from 'react';
-import PropTypes from 'prop-types';
-import Const from '../const';
+'use strict';
 
-const RowTemplate = props => {
-  const {
-    renderContent,
-    selectRow,
-    expandRow,
-    cellEl,
-    ...rest
-  } = props;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-  const isRenderFunctionColumnInLeft = (position = Const.INDICATOR_POSITION_LEFT) => position === Const.INDICATOR_POSITION_LEFT;
+var _react = require('react');
 
-  const childrens = renderContent() || [];
+var _react2 = _interopRequireDefault(_react);
 
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _const = require('../const');
+
+var _const2 = _interopRequireDefault(_const);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; } /* eslint react/require-default-props: 0 */
+
+
+var RowTemplate = function RowTemplate(props) {
+  var renderContent = props.renderContent,
+      selectRow = props.selectRow,
+      expandRow = props.expandRow,
+      cellEl = props.cellEl,
+      rest = _objectWithoutProperties(props, ['renderContent', 'selectRow', 'expandRow', 'cellEl']);
+
+  var isRenderFunctionColumnInLeft = function isRenderFunctionColumnInLeft() {
+    var position = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _const2.default.INDICATOR_POSITION_LEFT;
+    return position === _const2.default.INDICATOR_POSITION_LEFT;
+  };
+
+  var childrens = renderContent() || [];
+
   if (selectRow && selectRow.hideSelectColumn !== true) {
     if (isRenderFunctionColumnInLeft(selectRow.selectColumnPosition)) {
-      childrens.unshift( /*#__PURE__*/React.createElement(cellEl, {
-        key: 'selection'
-      }));
+      childrens.unshift(_react2.default.createElement(cellEl, { key: 'selection' }));
     } else {
-      childrens.push( /*#__PURE__*/React.createElement(cellEl, {
-        key: 'selection'
-      }));
+      childrens.push(_react2.default.createElement(cellEl, { key: 'selection' }));
     }
@@ -33,21 +48,22 @@ }
     if (isRenderFunctionColumnInLeft(expandRow.expandColumnPosition)) {
-      childrens.unshift( /*#__PURE__*/React.createElement(cellEl, {
-        key: 'expansion'
-      }));
+      childrens.unshift(_react2.default.createElement(cellEl, { key: 'expansion' }));
     } else {
-      childrens.push( /*#__PURE__*/React.createElement(cellEl, {
-        key: 'expansion'
-      }));
+      childrens.push(_react2.default.createElement(cellEl, { key: 'expansion' }));
     }
   }
 
-  return /*#__PURE__*/React.createElement("tr", rest, childrens);
+  return _react2.default.createElement(
+    'tr',
+    rest,
+    childrens
+  );
 };
 
 RowTemplate.propTypes = {
-  renderContent: PropTypes.func.isRequired,
-  cellEl: PropTypes.string.isRequired,
-  selectRow: PropTypes.object,
-  expandRow: PropTypes.object
+  renderContent: _propTypes2.default.func.isRequired,
+  cellEl: _propTypes2.default.string.isRequired,
+  selectRow: _propTypes2.default.object,
+  expandRow: _propTypes2.default.object
 };
-export default RowTemplate;
+
+exports.default = RowTemplate;

lib/src/row/should-updater.js

@@ -1,41 +0,80 @@
-/* eslint react/prop-types: 0 */
-import _ from '../utils';
-export default (ExtendBase => class RowShouldUpdater extends ExtendBase {
-  shouldUpdateByCellEditing(nextProps) {
-    if (!(this.props.clickToEdit || this.props.dbclickToEdit)) return false;
-    return nextProps.editingRowIdx === nextProps.rowIndex || this.props.editingRowIdx === nextProps.rowIndex && nextProps.editingRowIdx === null || this.props.editingRowIdx === nextProps.rowIndex;
-  }
+'use strict';
 
-  shouldUpdatedBySelfProps(nextProps) {
-    return this.props.className !== nextProps.className || !_.isEqual(this.props.style, nextProps.style) || !_.isEqual(this.props.attrs, nextProps.attrs);
-  } // Only use for simple-row
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-  shouldUpdateByColumnsForSimpleCheck(nextProps) {
-    if (this.props.columns.length !== nextProps.columns.length) {
-      return true;
+var _utils = require('../utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint react/prop-types: 0 */
+
+
+exports.default = function (ExtendBase) {
+  return function (_ExtendBase) {
+    _inherits(RowShouldUpdater, _ExtendBase);
+
+    function RowShouldUpdater() {
+      _classCallCheck(this, RowShouldUpdater);
+
+      return _possibleConstructorReturn(this, (RowShouldUpdater.__proto__ || Object.getPrototypeOf(RowShouldUpdater)).apply(this, arguments));
     }
 
-    for (let i = 0; i < this.props.columns.length; i += 1) {
-      if (!_.isEqual(this.props.columns[i], nextProps.columns[i])) {
-        return true;
+    _createClass(RowShouldUpdater, [{
+      key: 'shouldUpdateByCellEditing',
+      value: function shouldUpdateByCellEditing(nextProps) {
+        if (!(this.props.clickToEdit || this.props.dbclickToEdit)) return false;
+        return nextProps.editingRowIdx === nextProps.rowIndex || this.props.editingRowIdx === nextProps.rowIndex && nextProps.editingRowIdx === null || this.props.editingRowIdx === nextProps.rowIndex;
       }
-    }
+    }, {
+      key: 'shouldUpdatedBySelfProps',
+      value: function shouldUpdatedBySelfProps(nextProps) {
+        return this.props.className !== nextProps.className || !_utils2.default.isEqual(this.props.style, nextProps.style) || !_utils2.default.isEqual(this.props.attrs, nextProps.attrs);
+      }
 
-    return false;
-  }
+      // Only use for simple-row
 
-  shouldUpdatedByNormalProps(nextProps) {
-    const shouldUpdate = this.props.rowIndex !== nextProps.rowIndex || this.props.editable !== nextProps.editable || !_.isEqual(this.props.row, nextProps.row) || this.props.columns.length !== nextProps.columns.length;
-    return shouldUpdate;
-  }
+    }, {
+      key: 'shouldUpdateByColumnsForSimpleCheck',
+      value: function shouldUpdateByColumnsForSimpleCheck(nextProps) {
+        if (this.props.columns.length !== nextProps.columns.length) {
+          return true;
+        }
+        for (var i = 0; i < this.props.columns.length; i += 1) {
+          if (!_utils2.default.isEqual(this.props.columns[i], nextProps.columns[i])) {
+            return true;
+          }
+        }
+        return false;
+      }
+    }, {
+      key: 'shouldUpdatedByNormalProps',
+      value: function shouldUpdatedByNormalProps(nextProps) {
+        var shouldUpdate = this.props.rowIndex !== nextProps.rowIndex || this.props.editable !== nextProps.editable || !_utils2.default.isEqual(this.props.row, nextProps.row) || this.props.columns.length !== nextProps.columns.length;
 
-  shouldUpdateChild(nextProps) {
-    return this.shouldUpdateByCellEditing(nextProps) || this.shouldUpdatedByNormalProps(nextProps);
-  }
+        return shouldUpdate;
+      }
+    }, {
+      key: 'shouldUpdateChild',
+      value: function shouldUpdateChild(nextProps) {
+        return this.shouldUpdateByCellEditing(nextProps) || this.shouldUpdatedByNormalProps(nextProps);
+      }
+    }, {
+      key: 'shouldRowContentUpdate',
+      value: function shouldRowContentUpdate(nextProps) {
+        return this.shouldUpdateChild(nextProps) || this.shouldUpdateByColumnsForSimpleCheck(nextProps);
+      }
+    }]);
 
-  shouldRowContentUpdate(nextProps) {
-    return this.shouldUpdateChild(nextProps) || this.shouldUpdateByColumnsForSimpleCheck(nextProps);
-  }
-
-});
+    return RowShouldUpdater;
+  }(ExtendBase);
+};

lib/src/row/simple-row.js

@@ -1,55 +0,101 @@
-function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+'use strict';
 
-/* eslint react/prop-types: 0 */
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _rowPureContent = require('./row-pure-content');
+
+var _rowPureContent2 = _interopRequireDefault(_rowPureContent);
+
+var _eventDelegater = require('./event-delegater');
+
+var _eventDelegater2 = _interopRequireDefault(_eventDelegater);
+
+var _shouldUpdater2 = require('./should-updater');
+
+var _shouldUpdater3 = _interopRequireDefault(_shouldUpdater2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* eslint react/prop-types: 0 */
 /* eslint react/no-array-index-key: 0 */
-import React, { Component } from 'react';
-import PropTypes from 'prop-types';
-import RowPureContent from './row-pure-content';
-import eventDelegater from './event-delegater';
-import shouldUpdater from './should-updater';
 
-class SimpleRow extends shouldUpdater(eventDelegater(Component)) {
-  constructor(props) {
-    super(props);
-    this.shouldUpdateRowContent = false;
-  }
 
-  shouldComponentUpdate(nextProps) {
-    this.shouldUpdateRowContent = false;
-    this.shouldUpdateRowContent = this.shouldRowContentUpdate(nextProps);
-    if (this.shouldUpdateRowContent) return true;
-    return this.shouldUpdatedBySelfProps(nextProps);
-  }
+var SimpleRow = function (_shouldUpdater) {
+  _inherits(SimpleRow, _shouldUpdater);
 
-  render() {
-    const {
-      className,
-      style,
-      attrs,
-      visibleColumnSize,
-      tabIndexCell,
-      ...rest
-    } = this.props;
-    const trAttrs = this.delegate(attrs);
-    const tabIndexStart = this.props.rowIndex * visibleColumnSize + 1;
-    return /*#__PURE__*/React.createElement("tr", _extends({
-      style: style,
-      className: className
-    }, trAttrs), /*#__PURE__*/React.createElement(RowPureContent, _extends({
-      shouldUpdate: this.shouldUpdateRowContent,
-      tabIndexStart: tabIndexCell ? tabIndexStart : -1
-    }, rest)));
+  function SimpleRow(props) {
+    _classCallCheck(this, SimpleRow);
+
+    var _this = _possibleConstructorReturn(this, (SimpleRow.__proto__ || Object.getPrototypeOf(SimpleRow)).call(this, props));
+
+    _this.shouldUpdateRowContent = false;
+    return _this;
   }
 
-}
+  _createClass(SimpleRow, [{
+    key: 'shouldComponentUpdate',
+    value: function shouldComponentUpdate(nextProps) {
+      this.shouldUpdateRowContent = false;
+      this.shouldUpdateRowContent = this.shouldRowContentUpdate(nextProps);
+      if (this.shouldUpdateRowContent) return true;
 
+      return this.shouldUpdatedBySelfProps(nextProps);
+    }
+  }, {
+    key: 'render',
+    value: function render() {
+      var _props = this.props,
+          className = _props.className,
+          style = _props.style,
+          attrs = _props.attrs,
+          visibleColumnSize = _props.visibleColumnSize,
+          tabIndexCell = _props.tabIndexCell,
+          rest = _objectWithoutProperties(_props, ['className', 'style', 'attrs', 'visibleColumnSize', 'tabIndexCell']);
+
+      var trAttrs = this.delegate(attrs);
+      var tabIndexStart = this.props.rowIndex * visibleColumnSize + 1;
+
+      return _react2.default.createElement(
+        'tr',
+        _extends({ style: style, className: className }, trAttrs),
+        _react2.default.createElement(_rowPureContent2.default, _extends({
+          shouldUpdate: this.shouldUpdateRowContent,
+          tabIndexStart: tabIndexCell ? tabIndexStart : -1
+        }, rest))
+      );
+    }
+  }]);
+
+  return SimpleRow;
+}((0, _shouldUpdater3.default)((0, _eventDelegater2.default)(_react.Component)));
+
 SimpleRow.propTypes = {
-  row: PropTypes.object.isRequired,
-  rowIndex: PropTypes.number.isRequired,
-  columns: PropTypes.array.isRequired,
-  style: PropTypes.object,
-  className: PropTypes.string,
-  attrs: PropTypes.object
+  row: _propTypes2.default.object.isRequired,
+  rowIndex: _propTypes2.default.number.isRequired,
+  columns: _propTypes2.default.array.isRequired,
+  style: _propTypes2.default.object,
+  className: _propTypes2.default.string,
+  attrs: _propTypes2.default.object
 };
+
 SimpleRow.defaultProps = {
@@ -61,2 +107,3 @@ editable: true,
 };
-export default SimpleRow;
+
+exports.default = SimpleRow;

lib/src/sort/caret.js

@@ -1,27 +0,52 @@
-import React from 'react';
-import cs from 'classnames';
-import PropTypes from 'prop-types';
-import Const from '../const';
-import { BootstrapContext } from '../contexts/bootstrap';
+'use strict';
 
-const SortCaret = ({
-  order
-}) => {
-  const orderClass = cs('react-bootstrap-table-sort-order', {
-    dropup: order === Const.SORT_ASC
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _classnames = require('classnames');
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
+var _propTypes = require('prop-types');
+
+var _propTypes2 = _interopRequireDefault(_propTypes);
+
+var _const = require('../const');
+
+var _const2 = _interopRequireDefault(_const);
+
+var _bootstrap = require('../contexts/bootstrap');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var SortCaret = function SortCaret(_ref) {
+  var order = _ref.order;
+
+  var orderClass = (0, _classnames2.default)('react-bootstrap-table-sort-order', {
+    dropup: order === _const2.default.SORT_ASC
   });
-  return /*#__PURE__*/React.createElement(BootstrapContext.Consumer, null, ({
-    bootstrap4
-  }) => bootstrap4 ? /*#__PURE__*/React.createElement("span", {
-    className: `caret-4-${order}`
-  }) : /*#__PURE__*/React.createElement("span", {
-    className: orderClass
-  }, /*#__PURE__*/React.createElement("span", {
-    className: "caret"
-  })));
+
+  return _react2.default.createElement(
+    _bootstrap.BootstrapContext.Consumer,
+    null,
+    function (_ref2) {
+      var bootstrap4 = _ref2.bootstrap4;
+      return bootstrap4 ? _react2.default.createElement('span', { className: 'caret-4-' + order }) : _react2.default.createElement(
+        'span',
+        { className: orderClass },
+        _react2.default.createElement('span', { className: 'caret' })
+      );
+    }
+  );
 };
 
 SortCaret.propTypes = {
-  order: PropTypes.oneOf([Const.SORT_ASC, Const.SORT_DESC]).isRequired
+  order: _propTypes2.default.oneOf([_const2.default.SORT_ASC, _const2.default.SORT_DESC]).isRequired
 };
-export default SortCaret;
+
+exports.default = SortCaret;

lib/src/sort/symbol.js

@@ -1,20 +0,39 @@
-import React from 'react';
-import { BootstrapContext } from '../contexts/bootstrap';
+'use strict';
 
-const SortSymbol = () => /*#__PURE__*/React.createElement(BootstrapContext.Consumer, null, ({
-  bootstrap4
-}) => bootstrap4 ? /*#__PURE__*/React.createElement("span", {
-  className: "order-4"
-}) : /*#__PURE__*/React.createElement("span", {
-  className: "order"
-}, /*#__PURE__*/React.createElement("span", {
-  className: "dropdown"
-}, /*#__PURE__*/React.createElement("span", {
-  className: "caret"
-})), /*#__PURE__*/React.createElement("span", {
-  className: "dropup"
-}, /*#__PURE__*/React.createElement("span", {
-  className: "caret"
-}))));
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-export default SortSymbol;
+var _react = require('react');
+
+var _react2 = _interopRequireDefault(_react);
+
+var _bootstrap = require('../contexts/bootstrap');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var SortSymbol = function SortSymbol() {
+  return _react2.default.createElement(
+    _bootstrap.BootstrapContext.Consumer,
+    null,
+    function (_ref) {
+      var bootstrap4 = _ref.bootstrap4;
+      return bootstrap4 ? _react2.default.createElement('span', { className: 'order-4' }) : _react2.default.createElement(
+        'span',
+        { className: 'order' },
+        _react2.default.createElement(
+          'span',
+          { className: 'dropdown' },
+          _react2.default.createElement('span', { className: 'caret' })
+        ),
+        _react2.default.createElement(
+          'span',
+          { className: 'dropup' },
+          _react2.default.createElement('span', { className: 'caret' })
+        )
+      );
+    }
+  );
+};
+
+exports.default = SortSymbol;

lib/src/store/expand.js

@@ -1,21 +0,59 @@
-import _ from '../utils';
-import { getRowByRowId } from './rows';
-export const isAnyExpands = (data, keyField, expanded = []) => {
-  for (let i = 0; i < data.length; i += 1) {
-    const rowKey = _.get(data[i], keyField);
+'use strict';
 
-    if (typeof expanded.find(x => x === rowKey) !== 'undefined') {
-      return true;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getExpandedRows = exports.expandableKeys = exports.isAnyExpands = undefined;
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+var _utils = require('../utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+var _rows = require('./rows');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var isAnyExpands = exports.isAnyExpands = function isAnyExpands(data, keyField) {
+  var expanded = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+
+  var _loop = function _loop(i) {
+    var rowKey = _utils2.default.get(data[i], keyField);
+    if (typeof expanded.find(function (x) {
+      return x === rowKey;
+    }) !== 'undefined') {
+      return {
+        v: true
+      };
     }
+  };
+
+  for (var i = 0; i < data.length; i += 1) {
+    var _ret = _loop(i);
+
+    if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === "object") return _ret.v;
   }
-
   return false;
 };
-export const expandableKeys = (data, keyField, skips = []) => {
+
+var expandableKeys = exports.expandableKeys = function expandableKeys(data, keyField) {
+  var skips = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+
   if (skips.length === 0) {
-    return data.map(row => _.get(row, keyField));
+    return data.map(function (row) {
+      return _utils2.default.get(row, keyField);
+    });
   }
+  return data.filter(function (row) {
+    return !_utils2.default.contains(skips, _utils2.default.get(row, keyField));
+  }).map(function (row) {
+    return _utils2.default.get(row, keyField);
+  });
+};
 
-  return data.filter(row => !_.contains(skips, _.get(row, keyField))).map(row => _.get(row, keyField));
-};
-export const getExpandedRows = (data, keyField, expanded) => expanded.map(k => getRowByRowId(data, keyField, k));
+var getExpandedRows = exports.getExpandedRows = function getExpandedRows(data, keyField, expanded) {
+  return expanded.map(function (k) {
+    return (0, _rows.getRowByRowId)(data, keyField, k);
+  });
+};

lib/src/store/mutate.js

@@ -1,6 +0,19 @@
-import _ from '../utils';
-import { getRowByRowId } from './rows';
-export const editCell = (data, keyField, rowId, dataField, newValue) => {
-  const row = getRowByRowId(data, keyField, rowId);
-  if (row) _.set(row, dataField, newValue);
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.editCell = undefined;
+
+var _utils = require('../utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+var _rows = require('./rows');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var editCell = exports.editCell = function editCell(data, keyField, rowId, dataField, newValue) {
+  var row = (0, _rows.getRowByRowId)(data, keyField, rowId);
+  if (row) _utils2.default.set(row, dataField, newValue);
 };

lib/src/store/operators.js

@@ -1,13 +0,35 @@
-import * as rows from './rows';
-import * as selection from './selection';
-import * as expand from './expand';
-import * as mutate from './mutate';
-import * as sort from './sort';
-import * as type from './type';
-export default { ...rows,
-  ...selection,
-  ...expand,
-  ...mutate,
-  ...sort,
-  ...type
-};
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var _rows = require('./rows');
+
+var rows = _interopRequireWildcard(_rows);
+
+var _selection = require('./selection');
+
+var selection = _interopRequireWildcard(_selection);
+
+var _expand = require('./expand');
+
+var expand = _interopRequireWildcard(_expand);
+
+var _mutate = require('./mutate');
+
+var mutate = _interopRequireWildcard(_mutate);
+
+var _sort = require('./sort');
+
+var sort = _interopRequireWildcard(_sort);
+
+var _type = require('./type');
+
+var type = _interopRequireWildcard(_type);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+exports.default = _extends({}, rows, selection, expand, mutate, sort, type);

lib/src/store/rows.js

@@ -1,3 +0,22 @@
-import _ from '../utils';
-export const matchRow = (keyField, id) => row => _.get(row, keyField) === id;
-export const getRowByRowId = (data, keyField, id) => data.find(matchRow(keyField, id));
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getRowByRowId = exports.matchRow = undefined;
+
+var _utils = require('../utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var matchRow = exports.matchRow = function matchRow(keyField, id) {
+  return function (row) {
+    return _utils2.default.get(row, keyField) === id;
+  };
+};
+
+var getRowByRowId = exports.getRowByRowId = function getRowByRowId(data, keyField, id) {
+  return data.find(matchRow(keyField, id));
+};

lib/src/store/selection.js

@@ -1,12 +0,33 @@
-import _ from '../utils';
-import { getRowByRowId } from './rows';
-export const getSelectionSummary = (data = [], keyField, selected = []) => {
-  let allRowsSelected = data.length > 0;
-  let allRowsNotSelected = true;
-  const rowKeys = data.map(d => _.get(d, keyField));
+'use strict';
 
-  for (let i = 0; i < rowKeys.length; i += 1) {
-    const curr = rowKeys[i];
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSelectedRows = exports.unSelectableKeys = exports.selectableKeys = exports.getSelectionSummary = undefined;
 
-    if (typeof selected.find(x => x === curr) === 'undefined') {
+var _utils = require('../utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+var _rows = require('./rows');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var getSelectionSummary = exports.getSelectionSummary = function getSelectionSummary() {
+  var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var keyField = arguments[1];
+  var selected = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+
+  var allRowsSelected = data.length > 0;
+  var allRowsNotSelected = true;
+
+  var rowKeys = data.map(function (d) {
+    return _utils2.default.get(d, keyField);
+  });
+
+  var _loop = function _loop(i) {
+    var curr = rowKeys[i];
+    if (typeof selected.find(function (x) {
+      return x === curr;
+    }) === 'undefined') {
       allRowsSelected = false;
@@ -16,23 +37,50 @@ } else {
     }
+  };
+
+  for (var i = 0; i < rowKeys.length; i += 1) {
+    _loop(i);
   }
-
   return {
-    allRowsSelected,
-    allRowsNotSelected
+    allRowsSelected: allRowsSelected,
+    allRowsNotSelected: allRowsNotSelected
   };
 };
-export const selectableKeys = (data = [], keyField, skips = []) => {
+
+var selectableKeys = exports.selectableKeys = function selectableKeys() {
+  var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var keyField = arguments[1];
+  var skips = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+
   if (skips.length === 0) {
-    return data.map(row => _.get(row, keyField));
+    return data.map(function (row) {
+      return _utils2.default.get(row, keyField);
+    });
   }
+  return data.filter(function (row) {
+    return !_utils2.default.contains(skips, _utils2.default.get(row, keyField));
+  }).map(function (row) {
+    return _utils2.default.get(row, keyField);
+  });
+};
 
-  return data.filter(row => !_.contains(skips, _.get(row, keyField))).map(row => _.get(row, keyField));
-};
-export const unSelectableKeys = (selected, skips = []) => {
+var unSelectableKeys = exports.unSelectableKeys = function unSelectableKeys(selected) {
+  var skips = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+
   if (skips.length === 0) {
     return [];
   }
+  return selected.filter(function (x) {
+    return _utils2.default.contains(skips, x);
+  });
+};
 
-  return selected.filter(x => _.contains(skips, x));
-};
-export const getSelectedRows = (data = [], keyField, selected) => selected.map(k => getRowByRowId(data, keyField, k)).filter(x => !!x);
+var getSelectedRows = exports.getSelectedRows = function getSelectedRows() {
+  var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var keyField = arguments[1];
+  var selected = arguments[2];
+  return selected.map(function (k) {
+    return (0, _rows.getRowByRowId)(data, keyField, k);
+  }).filter(function (x) {
+    return !!x;
+  });
+};

lib/src/store/sort.js

@@ -1,12 +0,25 @@
-/* eslint no-nested-ternary: 0 */
+'use strict';
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.nextOrder = exports.sort = undefined;
+
+var _utils = require('../utils');
+
+var _utils2 = _interopRequireDefault(_utils);
+
+var _const = require('../const');
+
+var _const2 = _interopRequireDefault(_const);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } /* eslint no-nested-ternary: 0 */
 /* eslint no-lonely-if: 0 */
-
 /* eslint no-underscore-dangle: 0 */
-import _ from '../utils';
-import Const from '../const';
 
+
 function comparator(a, b) {
-  let result;
-
+  var result = void 0;
   if (typeof b === 'string') {
@@ -17,20 +30,15 @@ result = b.localeCompare(a);
   }
-
   return result;
 }
 
-export const sort = (data, sortOrder, {
-  dataField,
-  sortFunc,
-  sortValue
-}) => {
-  const _data = [...data];
+var sort = exports.sort = function sort(data, sortOrder, _ref) {
+  var dataField = _ref.dataField,
+      sortFunc = _ref.sortFunc,
+      sortValue = _ref.sortValue;
 
-  _data.sort((a, b) => {
-    let result;
-
-    let valueA = _.get(a, dataField);
-
-    let valueB = _.get(b, dataField);
-
+  var _data = [].concat(_toConsumableArray(data));
+  _data.sort(function (a, b) {
+    var result = void 0;
+    var valueA = _utils2.default.get(a, dataField);
+    var valueB = _utils2.default.get(b, dataField);
     if (sortValue) {
@@ -40,4 +48,4 @@ valueA = sortValue(valueA, a);
     } else {
-      valueA = _.isDefined(valueA) ? valueA : '';
-      valueB = _.isDefined(valueB) ? valueB : '';
+      valueA = _utils2.default.isDefined(valueA) ? valueA : '';
+      valueB = _utils2.default.isDefined(valueB) ? valueB : '';
     }
@@ -48,3 +56,3 @@
     } else {
-      if (sortOrder === Const.SORT_DESC) {
+      if (sortOrder === _const2.default.SORT_DESC) {
         result = comparator(valueA, valueB);
@@ -55,14 +63,16 @@ } else {
     }
-
     return result;
   });
-
   return _data;
 };
-export const nextOrder = (currentSortColumn, {
-  sortOrder,
-  sortColumn
-}, defaultOrder = Const.SORT_DESC) => {
-  if (!sortColumn || currentSortColumn.dataField !== sortColumn.dataField) return defaultOrder;
-  return sortOrder === Const.SORT_DESC ? Const.SORT_ASC : Const.SORT_DESC;
+
+var nextOrder = exports.nextOrder = function nextOrder(currentSortColumn, _ref2) {
+  var sortOrder = _ref2.sortOrder,
+      sortColumn = _ref2.sortColumn;
+  var defaultOrder = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _const2.default.SORT_DESC;
+
+  if (!sortColumn || currentSortColumn.dataField !== sortColumn.dataField) {
+    return defaultOrder;
+  }
+  return sortOrder === _const2.default.SORT_DESC ? _const2.default.SORT_ASC : _const2.default.SORT_DESC;
 };

lib/src/store/type.js

@@ -1,18 +0,28 @@
-import Const from '../const';
-export const typeConvert = (type, value) => {
-  if (type === Const.TYPE_STRING) {
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.typeConvert = undefined;
+
+var _const = require('../const');
+
+var _const2 = _interopRequireDefault(_const);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var typeConvert = exports.typeConvert = function typeConvert(type, value) {
+  if (type === _const2.default.TYPE_STRING) {
     return String(value);
-  } else if (type === Const.TYPE_NUMBER) {
+  } else if (type === _const2.default.TYPE_NUMBER) {
     return Number(value);
-  } else if (type === Const.TYPE_BOOLEAN) {
+  } else if (type === _const2.default.TYPE_BOOLEAN) {
     if (typeof value === 'boolean') {
       return value;
     }
-
     return value === 'true';
-  } else if (type === Const.TYPE_DATE) {
+  } else if (type === _const2.default.TYPE_DATE) {
     return new Date(value);
   }
-
   return value;
 };

lib/src/utils.js

@@ -1,15 +0,23 @@
-/* eslint no-empty: 0 */
+'use strict';
 
-/* eslint no-param-reassign: 0 */
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
 
-/* eslint prefer-rest-params: 0 */
-import _ from 'underscore';
+var _underscore = require('underscore');
 
+var _underscore2 = _interopRequireDefault(_underscore);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
 function splitNested(str) {
   return [str].join('.').replace(/\[/g, '.').replace(/\]/g, '').split('.');
-}
+} /* eslint no-empty: 0 */
+/* eslint no-param-reassign: 0 */
+/* eslint prefer-rest-params: 0 */
 
+
 function contains(list, value) {
-  if (_.includes) {
-    return _.includes(list, value);
+  if (_underscore2.default.includes) {
+    return _underscore2.default.includes(list, value);
   }
@@ -21,4 +29,3 @@
 function get(target, field) {
-  const directGet = target[field];
-
+  var directGet = target[field];
   if (directGet !== undefined && directGet !== null) {
@@ -28,20 +35,21 @@ return directGet;
 
-  const pathArray = splitNested(field);
-  let result;
-
+  var pathArray = splitNested(field);
+  var result = void 0;
   try {
-    result = pathArray.reduce((curr, path) => curr[path], target);
+    result = pathArray.reduce(function (curr, path) {
+      return curr[path];
+    }, target);
   } catch (e) {}
-
   return result;
 }
 
-function set(target, field, value, safe = false) {
-  const pathArray = splitNested(field);
-  let level = 0;
-  pathArray.reduce((a, b) => {
+function set(target, field, value) {
+  var safe = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+
+  var pathArray = splitNested(field);
+  var level = 0;
+  pathArray.reduce(function (a, b) {
     level += 1;
-
     if (typeof a[b] === 'undefined') {
-      if (!safe) throw new Error(`${a}.${b} is undefined`);
+      if (!safe) throw new Error(a + '.' + b + ' is undefined');
       a[b] = {};
@@ -55,3 +63,2 @@ return a[b];
     }
-
     return a[b];
@@ -62,7 +69,8 @@ }, target);
 function isEmptyObject(obj) {
-  if (!_.isObject(obj)) return false;
-  const hasOwnProperty = Object.prototype.hasOwnProperty;
-  const keys = Object.keys(obj);
+  if (!_underscore2.default.isObject(obj)) return false;
 
-  for (let i = 0; i < keys.length; i += 1) {
+  var hasOwnProperty = Object.prototype.hasOwnProperty;
+  var keys = Object.keys(obj);
+
+  for (var i = 0; i < keys.length; i += 1) {
     if (hasOwnProperty.call(obj, keys[i])) return false;
@@ -79,17 +87,24 @@ }
 function sleep(fn, ms) {
-  return setTimeout(() => fn(), ms);
+  return setTimeout(function () {
+    return fn();
+  }, ms);
 }
 
 function debounce(func, wait, immediate) {
-  let timeout;
-  return () => {
-    const later = () => {
+  var _this = this,
+      _arguments = arguments;
+
+  var timeout = void 0;
+
+  return function () {
+    var later = function later() {
       timeout = null;
 
       if (!immediate) {
-        func.apply(this, arguments);
+        func.apply(_this, _arguments);
       }
     };
 
-    const callNow = immediate && !timeout;
+    var callNow = immediate && !timeout;
+
     clearTimeout(timeout);
@@ -99,3 +114,3 @@ timeout = setTimeout(later, wait || 0);
     if (callNow) {
-      func.apply(this, arguments);
+      func.apply(_this, _arguments);
     }
@@ -105,10 +120,10 @@ };
 
-export default Object.assign(_, {
-  get,
-  set,
-  isDefined,
-  isEmptyObject,
-  sleep,
-  debounce,
-  contains
+exports.default = Object.assign(_underscore2.default, {
+  get: get,
+  set: set,
+  isDefined: isDefined,
+  isEmptyObject: isEmptyObject,
+  sleep: sleep,
+  debounce: debounce,
+  contains: contains
 });

package.json

 {
   "name": "@murasoftware/react-bootstrap-table-next",
-  "version": "4.1.3",
+  "version": "4.1.4",
   "description": "Next generation of react-bootstrap-table",
@@ -41,3 +41,3 @@ "main": "./lib/index.js",
     "react-transition-group": "^4.2.0",
-    "underscore": "^1.13.4"
+    "underscore": "1.9.1"
   },
@@ -44,0 +44,0 @@ "peerDependencies": {

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

206838

90.62%

Lines of code

4050

35.54%

Dependency changes

• + Added

  underscore@1.9.1
  (transitive)

• - Removed

  underscore@1.13.8
  (transitive)

• Updated

  underscore@1.9.1