From 4833868911bc8bc96de5e8e4b251e7b3a1045d25 Mon Sep 17 00:00:00 2001 From: Richard Antecki Date: Tue, 31 Jul 2018 11:53:05 +1000 Subject: [PATCH] Add compiled files to repo so I can import module via brunch without pain. --- .gitignore | 2 - es/defaultProps.js | 349 ++++++++++++++ es/hoc/foldableTable/index.js | 291 ++++++++++++ es/hoc/selectTable/index.js | 157 +++++++ es/hoc/treeTable/index.js | 118 +++++ es/index.js | 800 +++++++++++++++++++++++++++++++ es/lifecycle.js | 125 +++++ es/methods.js | 739 +++++++++++++++++++++++++++++ es/pagination.js | 200 ++++++++ es/propTypes.js | 165 +++++++ es/utils.js | 226 +++++++++ lib/defaultProps.js | 369 +++++++++++++++ lib/hoc/foldableTable/index.js | 307 ++++++++++++ lib/hoc/selectTable/index.js | 165 +++++++ lib/hoc/treeTable/index.js | 126 +++++ lib/index.js | 830 +++++++++++++++++++++++++++++++++ lib/lifecycle.js | 131 ++++++ lib/methods.js | 752 +++++++++++++++++++++++++++++ lib/pagination.js | 214 +++++++++ lib/propTypes.js | 175 +++++++ lib/utils.js | 241 ++++++++++ 21 files changed, 6480 insertions(+), 2 deletions(-) create mode 100644 es/defaultProps.js create mode 100644 es/hoc/foldableTable/index.js create mode 100644 es/hoc/selectTable/index.js create mode 100644 es/hoc/treeTable/index.js create mode 100644 es/index.js create mode 100644 es/lifecycle.js create mode 100644 es/methods.js create mode 100644 es/pagination.js create mode 100644 es/propTypes.js create mode 100644 es/utils.js create mode 100644 lib/defaultProps.js create mode 100644 lib/hoc/foldableTable/index.js create mode 100644 lib/hoc/selectTable/index.js create mode 100644 lib/hoc/treeTable/index.js create mode 100644 lib/index.js create mode 100644 lib/lifecycle.js create mode 100644 lib/methods.js create mode 100644 lib/pagination.js create mode 100644 lib/propTypes.js create mode 100644 lib/utils.js diff --git a/.gitignore b/.gitignore index edbea8e686..8b36f3d4b2 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,4 @@ node_modules/ -lib/ -es/ docs/build react-table.js react-table.min.js diff --git a/es/defaultProps.js b/es/defaultProps.js new file mode 100644 index 0000000000..73dabc3eab --- /dev/null +++ b/es/defaultProps.js @@ -0,0 +1,349 @@ +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; }; + +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; } + +import React from 'react'; +import classnames from 'classnames'; +// +import _ from './utils'; +import Pagination from './pagination'; + +var emptyObj = function emptyObj() { + return {}; +}; + +export default { + // General + data: [], + resolveData: function resolveData(data) { + return data; + }, + loading: false, + showPagination: true, + showPaginationTop: false, + showPaginationBottom: true, + showPageSizeOptions: true, + pageSizeOptions: [5, 10, 20, 25, 50, 100], + defaultPage: 0, + defaultPageSize: 20, + showPageJump: true, + collapseOnSortingChange: true, + collapseOnPageChange: true, + collapseOnDataChange: true, + freezeWhenExpanded: false, + sortable: true, + multiSort: true, + resizable: true, + filterable: false, + defaultSortDesc: false, + defaultSorted: [], + defaultFiltered: [], + defaultResized: [], + defaultExpanded: {}, + // eslint-disable-next-line no-unused-vars + defaultFilterMethod: function defaultFilterMethod(filter, row, column) { + var id = filter.pivotId || filter.id; + return row[id] !== undefined ? String(row[id]).startsWith(filter.value) : true; + }, + // eslint-disable-next-line no-unused-vars + defaultSortMethod: function defaultSortMethod(a, b, desc) { + // force null and undefined to the bottom + a = a === null || a === undefined ? '' : a; + b = b === null || b === undefined ? '' : b; + // force any string values to lowercase + a = typeof a === 'string' ? a.toLowerCase() : a; + b = typeof b === 'string' ? b.toLowerCase() : b; + // Return either 1 or -1 to indicate a sort priority + if (a > b) { + return 1; + } + if (a < b) { + return -1; + } + // returning 0, undefined or any falsey value will use subsequent sorts or + // the index as a tiebreaker + return 0; + }, + + // Controlled State Props + // page: undefined, + // pageSize: undefined, + // sorted: [], + // filtered: [], + // resized: [], + // expanded: {}, + + // Controlled State Callbacks + onPageChange: undefined, + onPageSizeChange: undefined, + onSortedChange: undefined, + onFilteredChange: undefined, + onResizedChange: undefined, + onExpandedChange: undefined, + + // Pivoting + pivotBy: undefined, + + // Key Constants + pivotValKey: '_pivotVal', + pivotIDKey: '_pivotID', + subRowsKey: '_subRows', + aggregatedKey: '_aggregated', + nestingLevelKey: '_nestingLevel', + originalKey: '_original', + indexKey: '_index', + groupedByPivotKey: '_groupedByPivot', + + // Server-side Callbacks + onFetchData: function onFetchData() { + return null; + }, + + // Classes + className: '', + style: {}, + + // Component decorators + getProps: emptyObj, + getTableProps: emptyObj, + getTheadGroupProps: emptyObj, + getTheadGroupTrProps: emptyObj, + getTheadGroupThProps: emptyObj, + getTheadProps: emptyObj, + getTheadTrProps: emptyObj, + getTheadThProps: emptyObj, + getTheadFilterProps: emptyObj, + getTheadFilterTrProps: emptyObj, + getTheadFilterThProps: emptyObj, + getTbodyProps: emptyObj, + getTrGroupProps: emptyObj, + getTrProps: emptyObj, + getTdProps: emptyObj, + getTfootProps: emptyObj, + getTfootTrProps: emptyObj, + getTfootTdProps: emptyObj, + getPaginationProps: emptyObj, + getLoadingProps: emptyObj, + getNoDataProps: emptyObj, + getResizerProps: emptyObj, + + // Global Column Defaults + column: { + // Renderers + Cell: undefined, + Header: undefined, + Footer: undefined, + Aggregated: undefined, + Pivot: undefined, + PivotValue: undefined, + Expander: undefined, + Filter: undefined, + // All Columns + sortable: undefined, // use table default + resizable: undefined, // use table default + filterable: undefined, // use table default + show: true, + minWidth: 100, + // Cells only + className: '', + style: {}, + getProps: emptyObj, + // Pivot only + aggregate: undefined, + // Headers only + headerClassName: '', + headerStyle: {}, + getHeaderProps: emptyObj, + // Footers only + footerClassName: '', + footerStyle: {}, + getFooterProps: emptyObj, + filterMethod: undefined, + filterAll: false, + sortMethod: undefined + }, + + // Global Expander Column Defaults + expanderDefaults: { + sortable: false, + resizable: false, + filterable: false, + width: 35 + }, + + pivotDefaults: { + // extend the defaults for pivoted columns here + }, + + // Text + previousText: 'Previous', + nextText: 'Next', + loadingText: 'Loading...', + noDataText: 'No rows found', + pageText: 'Page', + ofText: 'of', + rowsText: 'rows', + + // Components + TableComponent: function TableComponent(_ref) { + var children = _ref.children, + className = _ref.className, + rest = _objectWithoutProperties(_ref, ['children', 'className']); + + return React.createElement( + 'div', + _extends({ + className: classnames('rt-table', className), + role: 'grid' + // tabIndex='0' + }, rest), + children + ); + }, + TheadComponent: _.makeTemplateComponent('rt-thead', 'Thead'), + TbodyComponent: _.makeTemplateComponent('rt-tbody', 'Tbody'), + TrGroupComponent: function TrGroupComponent(_ref2) { + var children = _ref2.children, + className = _ref2.className, + rest = _objectWithoutProperties(_ref2, ['children', 'className']); + + return React.createElement( + 'div', + _extends({ className: classnames('rt-tr-group', className), role: 'rowgroup' }, rest), + children + ); + }, + TrComponent: function TrComponent(_ref3) { + var children = _ref3.children, + className = _ref3.className, + rest = _objectWithoutProperties(_ref3, ['children', 'className']); + + return React.createElement( + 'div', + _extends({ className: classnames('rt-tr', className), role: 'row' }, rest), + children + ); + }, + ThComponent: function ThComponent(_ref4) { + var toggleSort = _ref4.toggleSort, + className = _ref4.className, + children = _ref4.children, + rest = _objectWithoutProperties(_ref4, ['toggleSort', 'className', 'children']); + + return ( + // eslint-disable-next-line jsx-a11y/click-events-have-key-events + React.createElement( + 'div', + _extends({ + className: classnames('rt-th', className), + onClick: function onClick(e) { + return toggleSort && toggleSort(e); + }, + role: 'columnheader', + tabIndex: '-1' // Resolves eslint issues without implementing keyboard navigation incorrectly + }, rest), + children + ) + ); + }, + TdComponent: function TdComponent(_ref5) { + var toggleSort = _ref5.toggleSort, + className = _ref5.className, + children = _ref5.children, + rest = _objectWithoutProperties(_ref5, ['toggleSort', 'className', 'children']); + + return React.createElement( + 'div', + _extends({ className: classnames('rt-td', className), role: 'gridcell' }, rest), + children + ); + }, + TfootComponent: _.makeTemplateComponent('rt-tfoot', 'Tfoot'), + FilterComponent: function FilterComponent(_ref6) { + var filter = _ref6.filter, + _onChange = _ref6.onChange; + return React.createElement('input', { + type: 'text', + style: { + width: '100%' + }, + value: filter ? filter.value : '', + onChange: function onChange(event) { + return _onChange(event.target.value); + } + }); + }, + ExpanderComponent: function ExpanderComponent(_ref7) { + var isExpanded = _ref7.isExpanded; + return React.createElement( + 'div', + { className: classnames('rt-expander', isExpanded && '-open') }, + '\u2022' + ); + }, + PivotValueComponent: function PivotValueComponent(_ref8) { + var subRows = _ref8.subRows, + value = _ref8.value; + return React.createElement( + 'span', + null, + value, + ' ', + subRows && '(' + subRows.length + ')' + ); + }, + AggregatedComponent: function AggregatedComponent(_ref9) { + var subRows = _ref9.subRows, + column = _ref9.column; + + var previewValues = subRows.filter(function (d) { + return typeof d[column.id] !== 'undefined'; + }).map(function (row, i) { + return ( + // eslint-disable-next-line react/no-array-index-key + React.createElement( + 'span', + { key: i }, + row[column.id], + i < subRows.length - 1 ? ', ' : '' + ) + ); + }); + return React.createElement( + 'span', + null, + previewValues + ); + }, + PivotComponent: undefined, // this is a computed default generated using + // the ExpanderComponent and PivotValueComponent at run-time in methods.js + PaginationComponent: Pagination, + PreviousComponent: undefined, + NextComponent: undefined, + LoadingComponent: function LoadingComponent(_ref10) { + var className = _ref10.className, + loading = _ref10.loading, + loadingText = _ref10.loadingText, + rest = _objectWithoutProperties(_ref10, ['className', 'loading', 'loadingText']); + + return React.createElement( + 'div', + _extends({ className: classnames('-loading', { '-active': loading }, className) }, rest), + React.createElement( + 'div', + { className: '-loading-inner' }, + loadingText + ) + ); + }, + NoDataComponent: _.makeTemplateComponent('rt-noData', 'NoData'), + ResizerComponent: _.makeTemplateComponent('rt-resizer', 'Resizer'), + PadRowComponent: function PadRowComponent() { + return React.createElement( + 'span', + null, + '\xA0' + ); + } +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/defaultProps.js"],"names":["React","classnames","_","Pagination","emptyObj","data","resolveData","loading","showPagination","showPaginationTop","showPaginationBottom","showPageSizeOptions","pageSizeOptions","defaultPage","defaultPageSize","showPageJump","collapseOnSortingChange","collapseOnPageChange","collapseOnDataChange","freezeWhenExpanded","sortable","multiSort","resizable","filterable","defaultSortDesc","defaultSorted","defaultFiltered","defaultResized","defaultExpanded","defaultFilterMethod","filter","row","column","id","pivotId","undefined","String","startsWith","value","defaultSortMethod","a","b","desc","toLowerCase","onPageChange","onPageSizeChange","onSortedChange","onFilteredChange","onResizedChange","onExpandedChange","pivotBy","pivotValKey","pivotIDKey","subRowsKey","aggregatedKey","nestingLevelKey","originalKey","indexKey","groupedByPivotKey","onFetchData","className","style","getProps","getTableProps","getTheadGroupProps","getTheadGroupTrProps","getTheadGroupThProps","getTheadProps","getTheadTrProps","getTheadThProps","getTheadFilterProps","getTheadFilterTrProps","getTheadFilterThProps","getTbodyProps","getTrGroupProps","getTrProps","getTdProps","getTfootProps","getTfootTrProps","getTfootTdProps","getPaginationProps","getLoadingProps","getNoDataProps","getResizerProps","Cell","Header","Footer","Aggregated","Pivot","PivotValue","Expander","Filter","show","minWidth","aggregate","headerClassName","headerStyle","getHeaderProps","footerClassName","footerStyle","getFooterProps","filterMethod","filterAll","sortMethod","expanderDefaults","width","pivotDefaults","previousText","nextText","loadingText","noDataText","pageText","ofText","rowsText","TableComponent","children","rest","TheadComponent","makeTemplateComponent","TbodyComponent","TrGroupComponent","TrComponent","ThComponent","toggleSort","e","TdComponent","TfootComponent","FilterComponent","onChange","event","target","ExpanderComponent","isExpanded","PivotValueComponent","subRows","length","AggregatedComponent","previewValues","d","map","i","PivotComponent","PaginationComponent","PreviousComponent","NextComponent","LoadingComponent","NoDataComponent","ResizerComponent","PadRowComponent"],"mappings":"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","file":"defaultProps.js","sourcesContent":["import React from 'react'\nimport classnames from 'classnames'\n//\nimport _ from './utils'\nimport Pagination from './pagination'\n\nconst emptyObj = () => ({})\n\nexport default {\n  // General\n  data: [],\n  resolveData: data => data,\n  loading: false,\n  showPagination: true,\n  showPaginationTop: false,\n  showPaginationBottom: true,\n  showPageSizeOptions: true,\n  pageSizeOptions: [5, 10, 20, 25, 50, 100],\n  defaultPage: 0,\n  defaultPageSize: 20,\n  showPageJump: true,\n  collapseOnSortingChange: true,\n  collapseOnPageChange: true,\n  collapseOnDataChange: true,\n  freezeWhenExpanded: false,\n  sortable: true,\n  multiSort: true,\n  resizable: true,\n  filterable: false,\n  defaultSortDesc: false,\n  defaultSorted: [],\n  defaultFiltered: [],\n  defaultResized: [],\n  defaultExpanded: {},\n  // eslint-disable-next-line no-unused-vars\n  defaultFilterMethod: (filter, row, column) => {\n    const id = filter.pivotId || filter.id\n    return row[id] !== undefined ? String(row[id]).startsWith(filter.value) : true\n  },\n  // eslint-disable-next-line no-unused-vars\n  defaultSortMethod: (a, b, desc) => {\n    // force null and undefined to the bottom\n    a = a === null || a === undefined ? '' : a\n    b = b === null || b === undefined ? '' : b\n    // force any string values to lowercase\n    a = typeof a === 'string' ? a.toLowerCase() : a\n    b = typeof b === 'string' ? b.toLowerCase() : b\n    // Return either 1 or -1 to indicate a sort priority\n    if (a > b) {\n      return 1\n    }\n    if (a < b) {\n      return -1\n    }\n    // returning 0, undefined or any falsey value will use subsequent sorts or\n    // the index as a tiebreaker\n    return 0\n  },\n\n  // Controlled State Props\n  // page: undefined,\n  // pageSize: undefined,\n  // sorted: [],\n  // filtered: [],\n  // resized: [],\n  // expanded: {},\n\n  // Controlled State Callbacks\n  onPageChange: undefined,\n  onPageSizeChange: undefined,\n  onSortedChange: undefined,\n  onFilteredChange: undefined,\n  onResizedChange: undefined,\n  onExpandedChange: undefined,\n\n  // Pivoting\n  pivotBy: undefined,\n\n  // Key Constants\n  pivotValKey: '_pivotVal',\n  pivotIDKey: '_pivotID',\n  subRowsKey: '_subRows',\n  aggregatedKey: '_aggregated',\n  nestingLevelKey: '_nestingLevel',\n  originalKey: '_original',\n  indexKey: '_index',\n  groupedByPivotKey: '_groupedByPivot',\n\n  // Server-side Callbacks\n  onFetchData: () => null,\n\n  // Classes\n  className: '',\n  style: {},\n\n  // Component decorators\n  getProps: emptyObj,\n  getTableProps: emptyObj,\n  getTheadGroupProps: emptyObj,\n  getTheadGroupTrProps: emptyObj,\n  getTheadGroupThProps: emptyObj,\n  getTheadProps: emptyObj,\n  getTheadTrProps: emptyObj,\n  getTheadThProps: emptyObj,\n  getTheadFilterProps: emptyObj,\n  getTheadFilterTrProps: emptyObj,\n  getTheadFilterThProps: emptyObj,\n  getTbodyProps: emptyObj,\n  getTrGroupProps: emptyObj,\n  getTrProps: emptyObj,\n  getTdProps: emptyObj,\n  getTfootProps: emptyObj,\n  getTfootTrProps: emptyObj,\n  getTfootTdProps: emptyObj,\n  getPaginationProps: emptyObj,\n  getLoadingProps: emptyObj,\n  getNoDataProps: emptyObj,\n  getResizerProps: emptyObj,\n\n  // Global Column Defaults\n  column: {\n    // Renderers\n    Cell: undefined,\n    Header: undefined,\n    Footer: undefined,\n    Aggregated: undefined,\n    Pivot: undefined,\n    PivotValue: undefined,\n    Expander: undefined,\n    Filter: undefined,\n    // All Columns\n    sortable: undefined, // use table default\n    resizable: undefined, // use table default\n    filterable: undefined, // use table default\n    show: true,\n    minWidth: 100,\n    // Cells only\n    className: '',\n    style: {},\n    getProps: emptyObj,\n    // Pivot only\n    aggregate: undefined,\n    // Headers only\n    headerClassName: '',\n    headerStyle: {},\n    getHeaderProps: emptyObj,\n    // Footers only\n    footerClassName: '',\n    footerStyle: {},\n    getFooterProps: emptyObj,\n    filterMethod: undefined,\n    filterAll: false,\n    sortMethod: undefined,\n  },\n\n  // Global Expander Column Defaults\n  expanderDefaults: {\n    sortable: false,\n    resizable: false,\n    filterable: false,\n    width: 35,\n  },\n\n  pivotDefaults: {\n    // extend the defaults for pivoted columns here\n  },\n\n  // Text\n  previousText: 'Previous',\n  nextText: 'Next',\n  loadingText: 'Loading...',\n  noDataText: 'No rows found',\n  pageText: 'Page',\n  ofText: 'of',\n  rowsText: 'rows',\n\n  // Components\n  TableComponent: ({ children, className, ...rest }) => (\n    <div\n      className={classnames('rt-table', className)}\n      role=\"grid\"\n      // tabIndex='0'\n      {...rest}\n    >\n      {children}\n    </div>\n  ),\n  TheadComponent: _.makeTemplateComponent('rt-thead', 'Thead'),\n  TbodyComponent: _.makeTemplateComponent('rt-tbody', 'Tbody'),\n  TrGroupComponent: ({ children, className, ...rest }) => (\n    <div className={classnames('rt-tr-group', className)} role=\"rowgroup\" {...rest}>\n      {children}\n    </div>\n  ),\n  TrComponent: ({ children, className, ...rest }) => (\n    <div className={classnames('rt-tr', className)} role=\"row\" {...rest}>\n      {children}\n    </div>\n  ),\n  ThComponent: ({\n    toggleSort, className, children, ...rest\n  }) => (\n    // eslint-disable-next-line jsx-a11y/click-events-have-key-events\n    <div\n      className={classnames('rt-th', className)}\n      onClick={e => toggleSort && toggleSort(e)}\n      role=\"columnheader\"\n      tabIndex=\"-1\" // Resolves eslint issues without implementing keyboard navigation incorrectly\n      {...rest}\n    >\n      {children}\n    </div>\n  ),\n  TdComponent: ({\n    toggleSort, className, children, ...rest\n  }) => (\n    <div className={classnames('rt-td', className)} role=\"gridcell\" {...rest}>\n      {children}\n    </div>\n  ),\n  TfootComponent: _.makeTemplateComponent('rt-tfoot', 'Tfoot'),\n  FilterComponent: ({ filter, onChange }) => (\n    <input\n      type=\"text\"\n      style={{\n        width: '100%',\n      }}\n      value={filter ? filter.value : ''}\n      onChange={event => onChange(event.target.value)}\n    />\n  ),\n  ExpanderComponent: ({ isExpanded }) => (\n    <div className={classnames('rt-expander', isExpanded && '-open')}>&bull;</div>\n  ),\n  PivotValueComponent: ({ subRows, value }) => (\n    <span>\n      {value} {subRows && `(${subRows.length})`}\n    </span>\n  ),\n  AggregatedComponent: ({ subRows, column }) => {\n    const previewValues = subRows.filter(d => typeof d[column.id] !== 'undefined').map((row, i) => (\n      // eslint-disable-next-line react/no-array-index-key\n      <span key={i}>\n        {row[column.id]}\n        {i < subRows.length - 1 ? ', ' : ''}\n      </span>\n    ))\n    return <span>{previewValues}</span>\n  },\n  PivotComponent: undefined, // this is a computed default generated using\n  // the ExpanderComponent and PivotValueComponent at run-time in methods.js\n  PaginationComponent: Pagination,\n  PreviousComponent: undefined,\n  NextComponent: undefined,\n  LoadingComponent: ({\n    className, loading, loadingText, ...rest\n  }) => (\n    <div className={classnames('-loading', { '-active': loading }, className)} {...rest}>\n      <div className=\"-loading-inner\">{loadingText}</div>\n    </div>\n  ),\n  NoDataComponent: _.makeTemplateComponent('rt-noData', 'NoData'),\n  ResizerComponent: _.makeTemplateComponent('rt-resizer', 'Resizer'),\n  PadRowComponent: () => <span>&nbsp;</span>,\n}\n"]} \ No newline at end of file diff --git a/es/hoc/foldableTable/index.js b/es/hoc/foldableTable/index.js new file mode 100644 index 0000000000..7d5874cc2a --- /dev/null +++ b/es/hoc/foldableTable/index.js @@ -0,0 +1,291 @@ +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; }; }(); + +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 _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; } + +import React from 'react'; +import left from './left.svg'; +import right from './right.svg'; + +var defaultFoldIconComponent = function defaultFoldIconComponent(_ref) { + var collapsed = _ref.collapsed; + + var style = { width: 25 }; + + if (collapsed) return React.createElement('img', { src: right, style: style, alt: 'right' }); + return React.createElement('img', { src: left, style: style, alt: 'left' }); +}; + +var defaultFoldButtonComponent = function defaultFoldButtonComponent(_ref2) { + var header = _ref2.header, + collapsed = _ref2.collapsed, + icon = _ref2.icon, + onClick = _ref2.onClick; + + var style = { + marginLeft: "0px", + marginTop: "-5px", + marginBottom: "-8px", + float: "left", + cursor: "pointer" + }; + + return React.createElement( + 'div', + null, + React.createElement( + 'div', + { style: style, onClick: onClick }, + icon + ), + !collapsed && React.createElement( + 'div', + null, + header + ) + ); +}; + +export default (function (ReactTable) { + + var wrapper = function (_React$Component) { + _inherits(RTFoldableTable, _React$Component); + + function RTFoldableTable(props, context) { + _classCallCheck(this, RTFoldableTable); + + var _this = _possibleConstructorReturn(this, (RTFoldableTable.__proto__ || Object.getPrototypeOf(RTFoldableTable)).call(this, props, context)); + + _this.onResizedChange = function (resized) { + var onResizedChange = _this.props.onResizedChange; + + if (onResizedChange) onResizedChange(resized);else _this.setState(function (p) { + return { resized: resized }; + }); + }; + + _this.removeResized = function (column) { + var id = column.id; + + if (!id) return; + + var resized = _this.state.resized; + + if (!resized) return; + + var rs = resized.find(function (r) { + return r.id === id; + }); + if (!rs) return; + + var newResized = resized.filter(function (r) { + return r !== rs; + }); + _this.onResizedChange(newResized); + }; + + _this.getWrappedInstance = function () { + if (!_this.wrappedInstance) console.warn('RTFoldableTable - No wrapped instance'); + if (_this.wrappedInstance.getWrappedInstance) return _this.wrappedInstance.getWrappedInstance();else return _this.wrappedInstance; + }; + + _this.getCopiedKey = function (key) { + var foldableOriginalKey = _this.props.foldableOriginalKey; + + return '' + foldableOriginalKey + key; + }; + + _this.copyOriginals = function (column) { + var FoldedColumn = _this.props.FoldedColumn; + + //Stop copy if the column already copied + + if (column.original_Header) return; + + Object.keys(FoldedColumn).forEach(function (k) { + var copiedKey = _this.getCopiedKey(k); + + if (k === "Cell") column[copiedKey] = column[k] ? column[k] : function (c) { + return c.value; + };else column[copiedKey] = column[k]; + }); + + //Copy sub Columns + if (column.columns && !column.original_Columns) column.original_Columns = column.columns; + + //Copy Header + if (!column.original_Header) column.original_Header = column.Header; + }; + + _this.restoreToOriginal = function (column) { + var FoldedColumn = _this.props.FoldedColumn; + + + Object.keys(FoldedColumn).forEach(function (k) { + //ignore header as handling by foldableHeaderRender + if (k === "Header") return; + + var copiedKey = _this.getCopiedKey(k); + column[k] = column[copiedKey]; + }); + + if (column.columns && column.original_Columns) column.columns = column.original_Columns; + }; + + _this.getState = function () { + return _this.props.onFoldChange ? _this.props.folded : _this.state.folded; + }; + + _this.isFolded = function (col) { + var folded = _this.getState(); + return folded[col.id] === true; + }; + + _this.foldingHandler = function (col) { + if (!col || !col.id) return; + + var onFoldChange = _this.props.onFoldChange; + + var folded = _this.getState(); + var id = col.id; + + + var newFold = Object.assign({}, folded); + newFold[id] = !newFold[id]; + + //Remove the Resized if have + _this.removeResized(col); + + if (onFoldChange) onFoldChange(newFold);else _this.setState(function (previous) { + return { folded: newFold }; + }); + }; + + _this.foldableHeaderRender = function (cell) { + var _this$props = _this.props, + FoldButtonComponent = _this$props.FoldButtonComponent, + FoldIconComponent = _this$props.FoldIconComponent; + var column = cell.column; + + var collapsed = _this.isFolded(column); + var icon = React.createElement(FoldIconComponent, { collapsed: collapsed }); + var onClick = function onClick() { + return _this.foldingHandler(column); + }; + + return React.createElement(FoldButtonComponent, { header: column.original_Header, collapsed: collapsed, icon: icon, onClick: onClick }); + }; + + _this.applyFoldableForColumn = function (column) { + var collapsed = _this.isFolded(column); + var FoldedColumn = _this.props.FoldedColumn; + + //Handle Column Header + + if (column.columns) { + if (collapsed) { + column.columns = [FoldedColumn]; + column.width = FoldedColumn.width; + column.style = FoldedColumn.style; + } else _this.restoreToOriginal(column); + } + //Handle Normal Column. + else if (collapsed) column = Object.assign(column, FoldedColumn);else { + _this.restoreToOriginal(column); + } + }; + + _this.applyFoldableForColumns = function (columns) { + return columns.map(function (col, index) { + if (!col.foldable) return col; + + //If col don't have id then generate id based on index + if (!col.id) col.id = 'col_' + index; + + _this.copyOriginals(col); + //Replace current header with internal header render. + col.Header = function (c) { + return _this.foldableHeaderRender(c); + }; + //apply foldable + _this.applyFoldableForColumn(col); + + //return the new column out + return col; + }); + }; + + _this.state = { + folded: props.onFoldChange ? undefined : {}, + resized: props.resized || [] + }; + return _this; + } + + _createClass(RTFoldableTable, [{ + key: 'componentWillReceiveProps', + value: function componentWillReceiveProps(newProps) { + if (this.state.resized !== newProps.resized) this.setState(function (p) { + return { resized: newProps.resized }; + }); + } + + // this is so we can expose the underlying ReactTable. + + }, { + key: 'render', + value: function render() { + var _this2 = this; + + var _props = this.props, + originalCols = _props.columns, + FoldButtonComponent = _props.FoldButtonComponent, + FoldIconComponent = _props.FoldIconComponent, + FoldedColumn = _props.FoldedColumn, + rest = _objectWithoutProperties(_props, ['columns', 'FoldButtonComponent', 'FoldIconComponent', 'FoldedColumn']); + + var columns = this.applyFoldableForColumns([].concat(_toConsumableArray(originalCols))); + + var extra = { + columns: columns, + onResizedChange: this.onResizedChange, + resized: this.state.resized + }; + + return React.createElement(ReactTable, _extends({}, rest, extra, { ref: function ref(r) { + return _this2.wrappedInstance = r; + } })); + } + }]); + + return RTFoldableTable; + }(React.Component); + + wrapper.displayName = 'RTFoldableTable'; + wrapper.defaultProps = { + FoldIconComponent: defaultFoldIconComponent, + FoldButtonComponent: defaultFoldButtonComponent, + foldableOriginalKey: 'original_', + FoldedColumn: { + Cell: function Cell(c) { + return ''; + }, + width: 30, + sortable: false, + resizable: false, + filterable: false + } + }; + + return wrapper; +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/hoc/foldableTable/index.js"],"names":["React","left","right","defaultFoldIconComponent","collapsed","style","width","defaultFoldButtonComponent","header","icon","onClick","marginLeft","marginTop","marginBottom","float","cursor","ReactTable","wrapper","props","context","onResizedChange","resized","setState","removeResized","id","column","state","rs","find","r","newResized","filter","getWrappedInstance","wrappedInstance","console","warn","getCopiedKey","foldableOriginalKey","key","copyOriginals","FoldedColumn","original_Header","Object","keys","forEach","copiedKey","k","c","value","columns","original_Columns","Header","restoreToOriginal","getState","onFoldChange","folded","isFolded","col","foldingHandler","newFold","assign","foldableHeaderRender","cell","FoldButtonComponent","FoldIconComponent","createElement","applyFoldableForColumn","applyFoldableForColumns","map","index","foldable","undefined","newProps","originalCols","rest","extra","Component","displayName","defaultProps","Cell","sortable","resizable","filterable"],"mappings":"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","file":"index.js","sourcesContent":["import React from 'react';\nimport left from './left.svg';\nimport right from './right.svg';\n\nconst defaultFoldIconComponent = ({ collapsed }) => {\n    const style = { width: 25 };\n\n    if (collapsed)\n        return <img src={right} style={style} alt=\"right\" />\n    return <img src={left} style={style} alt=\"left\" />\n}\n\nconst defaultFoldButtonComponent = ({ header, collapsed, icon, onClick }) => {\n    const style = {\n        marginLeft: \"0px\",\n        marginTop: \"-5px\",\n        marginBottom: \"-8px\",\n        float: \"left\",\n        cursor: \"pointer\"\n    };\n\n    return (<div>\n        <div style={style} onClick={onClick}>\n            {icon}\n        </div>\n        {!collapsed && <div>{header}</div>}\n    </div>);\n}\n\nexport default (ReactTable) => {\n\n    const wrapper = class RTFoldableTable extends React.Component {\n        constructor(props, context) {\n            super(props, context);\n\n            this.state = {\n                folded: props.onFoldChange ? undefined : {},\n                resized: props.resized || []\n            };\n        }\n\n        componentWillReceiveProps(newProps) {\n            if (this.state.resized !== newProps.resized)\n                this.setState(p => { return { resized: newProps.resized } });\n        }\n\n        onResizedChange = resized => {\n            const { onResizedChange } = this.props;\n            if (onResizedChange)\n                onResizedChange(resized);\n            else this.setState(p => { return { resized } });\n        }\n\n        removeResized = column => {\n            const { id } = column;\n            if (!id) return;\n\n            const { resized } = this.state;\n            if (!resized) return;\n\n            const rs = resized.find(r => r.id === id);\n            if (!rs) return;\n\n            const newResized = resized.filter(r => r !== rs);\n            this.onResizedChange(newResized);\n        }\n\n        // this is so we can expose the underlying ReactTable.\n        getWrappedInstance = () => {\n            if (!this.wrappedInstance) console.warn('RTFoldableTable - No wrapped instance');\n            if (this.wrappedInstance.getWrappedInstance) return this.wrappedInstance.getWrappedInstance();\n            else return this.wrappedInstance\n        }\n\n        getCopiedKey = key => {\n            const { foldableOriginalKey } = this.props;\n            return `${foldableOriginalKey}${key}`;\n        }\n\n        copyOriginals = column => {\n            const { FoldedColumn } = this.props;\n\n            //Stop copy if the column already copied\n            if (column.original_Header) return;\n\n            Object.keys(FoldedColumn).forEach(k => {\n                const copiedKey = this.getCopiedKey(k);\n\n                if (k === \"Cell\")\n                    column[copiedKey] = column[k] ? column[k] : c => c.value;\n                else column[copiedKey] = column[k];\n            });\n\n            //Copy sub Columns\n            if (column.columns && !column.original_Columns)\n                column.original_Columns = column.columns;\n\n            //Copy Header\n            if (!column.original_Header)\n                column.original_Header = column.Header;\n        }\n\n        restoreToOriginal = column => {\n            const { FoldedColumn } = this.props;\n\n            Object.keys(FoldedColumn).forEach(k => {\n                //ignore header as handling by foldableHeaderRender\n                if (k === \"Header\") return;\n\n                const copiedKey = this.getCopiedKey(k);\n                column[k] = column[copiedKey];\n            });\n\n            if (column.columns && column.original_Columns)\n                column.columns = column.original_Columns;\n        }\n\n        getState = () => this.props.onFoldChange ? this.props.folded : this.state.folded;\n\n        isFolded = col => {\n            const folded = this.getState();\n            return folded[col.id] === true;\n        }\n\n        foldingHandler = col => {\n            if (!col || !col.id) return;\n\n            const { onFoldChange } = this.props;\n            const folded = this.getState();\n            const { id } = col;\n\n            let newFold = Object.assign({}, folded);\n            newFold[id] = !newFold[id];\n\n            //Remove the Resized if have\n            this.removeResized(col);\n\n            if (onFoldChange)\n                onFoldChange(newFold);\n            else this.setState(previous => { return { folded: newFold }; });\n        }\n\n        foldableHeaderRender = (cell) => {\n            const { FoldButtonComponent, FoldIconComponent } = this.props;\n            const { column } = cell;\n            const collapsed = this.isFolded(column);\n            const icon = React.createElement(FoldIconComponent, { collapsed });\n            const onClick = () => this.foldingHandler(column);\n\n            return React.createElement(FoldButtonComponent, { header: column.original_Header, collapsed, icon, onClick });\n        }\n\n        applyFoldableForColumn = column => {\n            const collapsed = this.isFolded(column);\n            const { FoldedColumn } = this.props;\n\n            //Handle Column Header\n            if (column.columns) {\n                if (collapsed) {\n                    column.columns = [FoldedColumn];\n                    column.width = FoldedColumn.width;\n                    column.style = FoldedColumn.style;\n                }\n                else this.restoreToOriginal(column);\n            }\n            //Handle Normal Column.\n            else if (collapsed)\n                column = Object.assign(column, FoldedColumn);\n            else {\n                this.restoreToOriginal(column);\n            }\n        }\n\n        applyFoldableForColumns = columns => {\n            return columns.map((col, index) => {\n                if (!col.foldable) return col;\n\n                //If col don't have id then generate id based on index\n                if (!col.id)\n                    col.id = `col_${index}`;\n\n                this.copyOriginals(col);\n                //Replace current header with internal header render.\n                col.Header = c => this.foldableHeaderRender(c);\n                //apply foldable\n                this.applyFoldableForColumn(col);\n\n                //return the new column out\n                return col;\n            });\n        }\n\n        render() {\n            const { columns: originalCols, FoldButtonComponent, FoldIconComponent, FoldedColumn, ...rest } = this.props;\n            const columns = this.applyFoldableForColumns([...originalCols]);\n\n            const extra = {\n                columns,\n                onResizedChange: this.onResizedChange,\n                resized: this.state.resized\n            };\n\n            return (\n                <ReactTable {...rest} {...extra} ref={r => this.wrappedInstance = r} />\n            )\n        }\n    }\n\n    wrapper.displayName = 'RTFoldableTable';\n    wrapper.defaultProps =\n        {\n            FoldIconComponent: defaultFoldIconComponent,\n            FoldButtonComponent: defaultFoldButtonComponent,\n            foldableOriginalKey: 'original_',\n            FoldedColumn: {\n                Cell: c => '',\n                width: 30,\n                sortable: false,\n                resizable: false,\n                filterable: false,\n            }\n        }\n\n    return wrapper;\n}"]} \ No newline at end of file diff --git a/es/hoc/selectTable/index.js b/es/hoc/selectTable/index.js new file mode 100644 index 0000000000..85cd49e1d4 --- /dev/null +++ b/es/hoc/selectTable/index.js @@ -0,0 +1,157 @@ +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; }; }(); + +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 _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-disable */ + +import React from 'react'; + +var defaultSelectInputComponent = function defaultSelectInputComponent(props) { + return React.createElement('input', { + type: props.selectType || 'checkbox', + checked: props.checked, + onClick: function onClick(e) { + var shiftKey = e.shiftKey; + + e.stopPropagation(); + props.onClick(props.id, shiftKey, props.row); + }, + onChange: function onChange() {} + }); +}; + +export default (function (Component) { + var wrapper = function (_React$Component) { + _inherits(RTSelectTable, _React$Component); + + function RTSelectTable(props) { + _classCallCheck(this, RTSelectTable); + + return _possibleConstructorReturn(this, (RTSelectTable.__proto__ || Object.getPrototypeOf(RTSelectTable)).call(this, props)); + } + + _createClass(RTSelectTable, [{ + key: 'rowSelector', + value: function rowSelector(row) { + if (!row || !row.hasOwnProperty(this.props.keyField)) return null; + var _props = this.props, + toggleSelection = _props.toggleSelection, + selectType = _props.selectType, + keyField = _props.keyField; + + var checked = this.props.isSelected(row[this.props.keyField]); + var inputProps = { + checked: checked, + onClick: toggleSelection, + selectType: selectType, + id: row[keyField], + row: row + }; + return React.createElement(this.props.SelectInputComponent, inputProps); + } + }, { + key: 'headSelector', + value: function headSelector(row) { + var selectType = this.props.selectType; + + if (selectType === 'radio') return null; + + var _props2 = this.props, + toggleAll = _props2.toggleAll, + checked = _props2.selectAll, + SelectAllInputComponent = _props2.SelectAllInputComponent; + + var inputProps = { + checked: checked, + onClick: toggleAll, + selectType: selectType + }; + + return React.createElement(SelectAllInputComponent, inputProps); + } + + // this is so we can expose the underlying ReactTable to get at the sortedData for selectAll + + }, { + key: 'getWrappedInstance', + value: function getWrappedInstance() { + if (!this.wrappedInstance) console.warn('RTSelectTable - No wrapped instance'); + if (this.wrappedInstance.getWrappedInstance) return this.wrappedInstance.getWrappedInstance();else return this.wrappedInstance; + } + }, { + key: 'render', + value: function render() { + var _this2 = this; + + var _props3 = this.props, + originalCols = _props3.columns, + isSelected = _props3.isSelected, + toggleSelection = _props3.toggleSelection, + toggleAll = _props3.toggleAll, + keyField = _props3.keyField, + selectAll = _props3.selectAll, + selectType = _props3.selectType, + selectWidth = _props3.selectWidth, + SelectAllInputComponent = _props3.SelectAllInputComponent, + SelectInputComponent = _props3.SelectInputComponent, + rest = _objectWithoutProperties(_props3, ['columns', 'isSelected', 'toggleSelection', 'toggleAll', 'keyField', 'selectAll', 'selectType', 'selectWidth', 'SelectAllInputComponent', 'SelectInputComponent']); + + var select = { + id: '_selector', + accessor: function accessor() { + return 'x'; + }, // this value is not important + Header: this.headSelector.bind(this), + Cell: function Cell(ci) { + return _this2.rowSelector.bind(_this2)(ci.original); + }, + width: selectWidth || 30, + filterable: false, + sortable: false, + resizable: false, + style: { textAlign: 'center' } + }; + var columns = [select].concat(_toConsumableArray(originalCols)); + var extra = { + columns: columns + }; + return React.createElement(Component, _extends({}, rest, extra, { ref: function ref(r) { + return _this2.wrappedInstance = r; + } })); + } + }]); + + return RTSelectTable; + }(React.Component); + + wrapper.displayName = 'RTSelectTable'; + wrapper.defaultProps = { + keyField: '_id', + isSelected: function isSelected(key) { + console.log('No isSelected handler provided:', { key: key }); + }, + selectAll: false, + toggleSelection: function toggleSelection(key, shift, row) { + console.log('No toggleSelection handler provided:', { key: key, shift: shift, row: row }); + }, + toggleAll: function toggleAll() { + console.log('No toggleAll handler provided.'); + }, + selectType: 'check', + SelectInputComponent: defaultSelectInputComponent, + SelectAllInputComponent: defaultSelectInputComponent + }; + + return wrapper; +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/hoc/selectTable/index.js"],"names":["React","defaultSelectInputComponent","props","selectType","checked","shiftKey","e","stopPropagation","onClick","id","row","wrapper","hasOwnProperty","keyField","toggleSelection","isSelected","inputProps","createElement","SelectInputComponent","toggleAll","selectAll","SelectAllInputComponent","wrappedInstance","console","warn","getWrappedInstance","originalCols","columns","selectWidth","rest","select","accessor","Header","headSelector","bind","Cell","rowSelector","ci","original","width","filterable","sortable","resizable","style","textAlign","extra","r","Component","displayName","defaultProps","log","key","shift"],"mappings":";;;;;;;;;;;;;;AAAA;;AAEA,OAAOA,KAAP,MAAkB,OAAlB;;AAEA,IAAMC,8BAA8B,SAA9BA,2BAA8B,QAAS;AAC3C,SACE;AACE,UAAMC,MAAMC,UAAN,IAAoB,UAD5B;AAEE,aAASD,MAAME,OAFjB;AAGE,aAAS,oBAAK;AAAA,UACJC,QADI,GACSC,CADT,CACJD,QADI;;AAEZC,QAAEC,eAAF;AACAL,YAAMM,OAAN,CAAcN,MAAMO,EAApB,EAAwBJ,QAAxB,EAAkCH,MAAMQ,GAAxC;AACD,KAPH;AAQE,cAAU,oBAAM,CAAE;AARpB,IADF;AAYD,CAbD;;AAeA,gBAAe,qBAAa;AAC1B,MAAMC;AAAA;;AACJ,2BAAYT,KAAZ,EAAmB;AAAA;;AAAA,2HACXA,KADW;AAElB;;AAHG;AAAA;AAAA,kCAKQQ,GALR,EAKa;AACf,YAAI,CAACA,GAAD,IAAQ,CAACA,IAAIE,cAAJ,CAAmB,KAAKV,KAAL,CAAWW,QAA9B,CAAb,EAAsD,OAAO,IAAP;AADvC,qBAEmC,KAAKX,KAFxC;AAAA,YAEPY,eAFO,UAEPA,eAFO;AAAA,YAEUX,UAFV,UAEUA,UAFV;AAAA,YAEsBU,QAFtB,UAEsBA,QAFtB;;AAGf,YAAMT,UAAU,KAAKF,KAAL,CAAWa,UAAX,CAAsBL,IAAI,KAAKR,KAAL,CAAWW,QAAf,CAAtB,CAAhB;AACA,YAAMG,aAAa;AACjBZ,0BADiB;AAEjBI,mBAASM,eAFQ;AAGjBX,gCAHiB;AAIjBM,cAAIC,IAAIG,QAAJ,CAJa;AAKjBH;AALiB,SAAnB;AAOA,eAAOV,MAAMiB,aAAN,CAAoB,KAAKf,KAAL,CAAWgB,oBAA/B,EAAqDF,UAArD,CAAP;AACD;AAjBG;AAAA;AAAA,mCAmBSN,GAnBT,EAmBc;AAAA,YACRP,UADQ,GACO,KAAKD,KADZ,CACRC,UADQ;;AAEhB,YAAIA,eAAe,OAAnB,EAA4B,OAAO,IAAP;;AAFZ,sBAImD,KAAKD,KAJxD;AAAA,YAIRiB,SAJQ,WAIRA,SAJQ;AAAA,YAIcf,OAJd,WAIGgB,SAJH;AAAA,YAIuBC,uBAJvB,WAIuBA,uBAJvB;;AAKhB,YAAML,aAAa;AACjBZ,0BADiB;AAEjBI,mBAASW,SAFQ;AAGjBhB;AAHiB,SAAnB;;AAMA,eAAOH,MAAMiB,aAAN,CAAoBI,uBAApB,EAA6CL,UAA7C,CAAP;AACD;;AAED;;AAjCI;AAAA;AAAA,2CAkCiB;AACnB,YAAI,CAAC,KAAKM,eAAV,EAA2BC,QAAQC,IAAR,CAAa,qCAAb;AAC3B,YAAI,KAAKF,eAAL,CAAqBG,kBAAzB,EAA6C,OAAO,KAAKH,eAAL,CAAqBG,kBAArB,EAAP,CAA7C,KACK,OAAO,KAAKH,eAAZ;AACN;AAtCG;AAAA;AAAA,+BAwCK;AAAA;;AAAA,sBAaH,KAAKpB,KAbF;AAAA,YAEIwB,YAFJ,WAELC,OAFK;AAAA,YAGLZ,UAHK,WAGLA,UAHK;AAAA,YAILD,eAJK,WAILA,eAJK;AAAA,YAKLK,SALK,WAKLA,SALK;AAAA,YAMLN,QANK,WAMLA,QANK;AAAA,YAOLO,SAPK,WAOLA,SAPK;AAAA,YAQLjB,UARK,WAQLA,UARK;AAAA,YASLyB,WATK,WASLA,WATK;AAAA,YAULP,uBAVK,WAULA,uBAVK;AAAA,YAWLH,oBAXK,WAWLA,oBAXK;AAAA,YAYFW,IAZE;;AAcP,YAAMC,SAAS;AACbrB,cAAI,WADS;AAEbsB,oBAAU;AAAA,mBAAM,GAAN;AAAA,WAFG,EAEQ;AACrBC,kBAAQ,KAAKC,YAAL,CAAkBC,IAAlB,CAAuB,IAAvB,CAHK;AAIbC,gBAAM,kBAAM;AACV,mBAAO,OAAKC,WAAL,CAAiBF,IAAjB,CAAsB,MAAtB,EAA4BG,GAAGC,QAA/B,CAAP;AACD,WANY;AAObC,iBAAOX,eAAe,EAPT;AAQbY,sBAAY,KARC;AASbC,oBAAU,KATG;AAUbC,qBAAW,KAVE;AAWbC,iBAAO,EAAEC,WAAW,QAAb;AAXM,SAAf;AAaA,YAAMjB,WAAWG,MAAX,4BAAsBJ,YAAtB,EAAN;AACA,YAAMmB,QAAQ;AACZlB;AADY,SAAd;AAGA,eAAO,oBAAC,SAAD,eAAeE,IAAf,EAAyBgB,KAAzB,IAAgC,KAAK;AAAA,mBAAM,OAAKvB,eAAL,GAAuBwB,CAA7B;AAAA,WAArC,IAAP;AACD;AAxEG;;AAAA;AAAA,IAAsC9C,MAAM+C,SAA5C,CAAN;;AA2EApC,UAAQqC,WAAR,GAAsB,eAAtB;AACArC,UAAQsC,YAAR,GAAuB;AACrBpC,cAAU,KADW;AAErBE,gBAAY,yBAAO;AACjBQ,cAAQ2B,GAAR,CAAY,iCAAZ,EAA+C,EAAEC,QAAF,EAA/C;AACD,KAJoB;AAKrB/B,eAAW,KALU;AAMrBN,qBAAiB,yBAACqC,GAAD,EAAMC,KAAN,EAAa1C,GAAb,EAAqB;AACpCa,cAAQ2B,GAAR,CAAY,sCAAZ,EAAoD,EAAEC,QAAF,EAAOC,YAAP,EAAc1C,QAAd,EAApD;AACD,KARoB;AASrBS,eAAW,qBAAM;AACfI,cAAQ2B,GAAR,CAAY,gCAAZ;AACD,KAXoB;AAYrB/C,gBAAY,OAZS;AAarBe,0BAAsBjB,2BAbD;AAcrBoB,6BAAyBpB;AAdJ,GAAvB;;AAiBA,SAAOU,OAAP;AACD,CA/FD","file":"index.js","sourcesContent":["/* eslint-disable */\n\nimport React from 'react'\n\nconst defaultSelectInputComponent = props => {\n  return (\n    <input\n      type={props.selectType || 'checkbox'}\n      checked={props.checked}\n      onClick={e => {\n        const { shiftKey } = e\n        e.stopPropagation()\n        props.onClick(props.id, shiftKey, props.row)\n      }}\n      onChange={() => {}}\n    />\n  )\n}\n\nexport default Component => {\n  const wrapper = class RTSelectTable extends React.Component {\n    constructor(props) {\n      super(props)\n    }\n\n    rowSelector(row) {\n      if (!row || !row.hasOwnProperty(this.props.keyField)) return null\n      const { toggleSelection, selectType, keyField } = this.props\n      const checked = this.props.isSelected(row[this.props.keyField])\n      const inputProps = {\n        checked,\n        onClick: toggleSelection,\n        selectType,\n        id: row[keyField],\n        row,\n      }\n      return React.createElement(this.props.SelectInputComponent, inputProps)\n    }\n\n    headSelector(row) {\n      const { selectType } = this.props\n      if (selectType === 'radio') return null\n\n      const { toggleAll, selectAll: checked, SelectAllInputComponent } = this.props\n      const inputProps = {\n        checked,\n        onClick: toggleAll,\n        selectType,\n      }\n\n      return React.createElement(SelectAllInputComponent, inputProps)\n    }\n\n    // this is so we can expose the underlying ReactTable to get at the sortedData for selectAll\n    getWrappedInstance() {\n      if (!this.wrappedInstance) console.warn('RTSelectTable - No wrapped instance')\n      if (this.wrappedInstance.getWrappedInstance) return this.wrappedInstance.getWrappedInstance()\n      else return this.wrappedInstance\n    }\n\n    render() {\n      const {\n        columns: originalCols,\n        isSelected,\n        toggleSelection,\n        toggleAll,\n        keyField,\n        selectAll,\n        selectType,\n        selectWidth,\n        SelectAllInputComponent,\n        SelectInputComponent,\n        ...rest\n      } = this.props\n      const select = {\n        id: '_selector',\n        accessor: () => 'x', // this value is not important\n        Header: this.headSelector.bind(this),\n        Cell: ci => {\n          return this.rowSelector.bind(this)(ci.original)\n        },\n        width: selectWidth || 30,\n        filterable: false,\n        sortable: false,\n        resizable: false,\n        style: { textAlign: 'center' },\n      }\n      const columns = [select, ...originalCols]\n      const extra = {\n        columns,\n      }\n      return <Component {...rest} {...extra} ref={r => (this.wrappedInstance = r)} />\n    }\n  }\n\n  wrapper.displayName = 'RTSelectTable'\n  wrapper.defaultProps = {\n    keyField: '_id',\n    isSelected: key => {\n      console.log('No isSelected handler provided:', { key })\n    },\n    selectAll: false,\n    toggleSelection: (key, shift, row) => {\n      console.log('No toggleSelection handler provided:', { key, shift, row })\n    },\n    toggleAll: () => {\n      console.log('No toggleAll handler provided.')\n    },\n    selectType: 'check',\n    SelectInputComponent: defaultSelectInputComponent,\n    SelectAllInputComponent: defaultSelectInputComponent,\n  }\n\n  return wrapper\n}\n"]} \ No newline at end of file diff --git a/es/hoc/treeTable/index.js b/es/hoc/treeTable/index.js new file mode 100644 index 0000000000..8641da2605 --- /dev/null +++ b/es/hoc/treeTable/index.js @@ -0,0 +1,118 @@ +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; }; }(); + +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-disable */ + +import React from 'react'; + +export default (function (Component) { + var _class, _temp, _initialiseProps; + + var wrapper = (_temp = _class = function (_React$Component) { + _inherits(RTTreeTable, _React$Component); + + function RTTreeTable(props) { + _classCallCheck(this, RTTreeTable); + + var _this = _possibleConstructorReturn(this, (RTTreeTable.__proto__ || Object.getPrototypeOf(RTTreeTable)).call(this, props)); + + _initialiseProps.call(_this); + + _this.getWrappedInstance.bind(_this); + _this.TrComponent.bind(_this); + _this.getTrProps.bind(_this); + return _this; + } + + // this is so we can expose the underlying ReactTable to get at the sortedData for selectAll + + + _createClass(RTTreeTable, [{ + key: 'render', + value: function render() { + var _this2 = this; + + var _props = this.props, + columns = _props.columns, + treeTableIndent = _props.treeTableIndent, + rest = _objectWithoutProperties(_props, ['columns', 'treeTableIndent']); + + var TrComponent = this.TrComponent, + getTrProps = this.getTrProps; + + var extra = { + columns: columns.map(function (col) { + var column = col; + if (rest.pivotBy && rest.pivotBy.includes(col.accessor)) { + column = { + accessor: col.accessor, + width: treeTableIndent + 'px', + show: false, + Header: '' + }; + } + return column; + }), + TrComponent: TrComponent, + getTrProps: getTrProps + }; + + return React.createElement(Component, _extends({}, rest, extra, { ref: function ref(r) { + return _this2.wrappedInstance = r; + } })); + } + }]); + + return RTTreeTable; + }(React.Component), _initialiseProps = function _initialiseProps() { + var _this3 = this; + + this.getWrappedInstance = function () { + if (!_this3.wrappedInstance) console.warn('RTTreeTable - No wrapped instance'); + if (_this3.wrappedInstance.getWrappedInstance) return _this3.wrappedInstance.getWrappedInstance();else return _this3.wrappedInstance; + }; + + this.TrComponent = function (props) { + var ri = props.ri, + rest = _objectWithoutProperties(props, ['ri']); + + if (ri && ri.groupedByPivot) { + var cell = _extends({}, props.children[ri.level]); + + cell.props.style.flex = 'unset'; + cell.props.style.width = '100%'; + cell.props.style.maxWidth = 'unset'; + cell.props.style.paddingLeft = _this3.props.treeTableIndent * ri.level + 'px'; + // cell.props.style.backgroundColor = '#DDD'; + cell.props.style.borderBottom = '1px solid rgba(128,128,128,0.2)'; + + return React.createElement( + 'div', + { className: 'rt-tr ' + rest.className, style: rest.style }, + cell + ); + } + return React.createElement(Component.defaultProps.TrComponent, rest); + }; + + this.getTrProps = function (state, ri, ci, instance) { + return { ri: ri }; + }; + }, _temp); + wrapper.displayName = 'RTTreeTable'; + wrapper.defaultProps = { + treeTableIndent: 10 + }; + + return wrapper; +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/es/index.js b/es/index.js new file mode 100644 index 0000000000..e9d4469ae6 --- /dev/null +++ b/es/index.js @@ -0,0 +1,800 @@ +var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); + +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; }; }(); + +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; } + +import React, { Component } from 'react'; +import classnames from 'classnames'; +// +import _ from './utils'; +import Lifecycle from './lifecycle'; +import Methods from './methods'; +import defaultProps from './defaultProps'; +import propTypes from './propTypes'; + +export var ReactTableDefaults = defaultProps; + +var ReactTable = function (_Methods) { + _inherits(ReactTable, _Methods); + + function ReactTable(props) { + _classCallCheck(this, ReactTable); + + var _this = _possibleConstructorReturn(this, (ReactTable.__proto__ || Object.getPrototypeOf(ReactTable)).call(this)); + + _this.getResolvedState = _this.getResolvedState.bind(_this); + _this.getDataModel = _this.getDataModel.bind(_this); + _this.getSortedData = _this.getSortedData.bind(_this); + _this.fireFetchData = _this.fireFetchData.bind(_this); + _this.getPropOrState = _this.getPropOrState.bind(_this); + _this.getStateOrProp = _this.getStateOrProp.bind(_this); + _this.filterData = _this.filterData.bind(_this); + _this.sortData = _this.sortData.bind(_this); + _this.getMinRows = _this.getMinRows.bind(_this); + _this.onPageChange = _this.onPageChange.bind(_this); + _this.onPageSizeChange = _this.onPageSizeChange.bind(_this); + _this.sortColumn = _this.sortColumn.bind(_this); + _this.filterColumn = _this.filterColumn.bind(_this); + _this.resizeColumnStart = _this.resizeColumnStart.bind(_this); + _this.resizeColumnEnd = _this.resizeColumnEnd.bind(_this); + _this.resizeColumnMoving = _this.resizeColumnMoving.bind(_this); + + _this.state = { + page: props.defaultPage, + pageSize: props.defaultPageSize, + sorted: props.defaultSorted, + expanded: props.defaultExpanded, + filtered: props.defaultFiltered, + resized: props.defaultResized, + currentlyResizing: false, + skipNextSort: false + }; + return _this; + } + + _createClass(ReactTable, [{ + key: 'render', + value: function render() { + var _this2 = this; + + var resolvedState = this.getResolvedState(); + var children = resolvedState.children, + className = resolvedState.className, + style = resolvedState.style, + getProps = resolvedState.getProps, + getTableProps = resolvedState.getTableProps, + getTheadGroupProps = resolvedState.getTheadGroupProps, + getTheadGroupTrProps = resolvedState.getTheadGroupTrProps, + getTheadGroupThProps = resolvedState.getTheadGroupThProps, + getTheadProps = resolvedState.getTheadProps, + getTheadTrProps = resolvedState.getTheadTrProps, + getTheadThProps = resolvedState.getTheadThProps, + getTheadFilterProps = resolvedState.getTheadFilterProps, + getTheadFilterTrProps = resolvedState.getTheadFilterTrProps, + getTheadFilterThProps = resolvedState.getTheadFilterThProps, + getTbodyProps = resolvedState.getTbodyProps, + getTrGroupProps = resolvedState.getTrGroupProps, + getTrProps = resolvedState.getTrProps, + getTdProps = resolvedState.getTdProps, + getTfootProps = resolvedState.getTfootProps, + getTfootTrProps = resolvedState.getTfootTrProps, + getTfootTdProps = resolvedState.getTfootTdProps, + getPaginationProps = resolvedState.getPaginationProps, + getLoadingProps = resolvedState.getLoadingProps, + getNoDataProps = resolvedState.getNoDataProps, + getResizerProps = resolvedState.getResizerProps, + showPagination = resolvedState.showPagination, + showPaginationTop = resolvedState.showPaginationTop, + showPaginationBottom = resolvedState.showPaginationBottom, + manual = resolvedState.manual, + loadingText = resolvedState.loadingText, + noDataText = resolvedState.noDataText, + sortable = resolvedState.sortable, + multiSort = resolvedState.multiSort, + resizable = resolvedState.resizable, + filterable = resolvedState.filterable, + pivotIDKey = resolvedState.pivotIDKey, + pivotValKey = resolvedState.pivotValKey, + pivotBy = resolvedState.pivotBy, + subRowsKey = resolvedState.subRowsKey, + aggregatedKey = resolvedState.aggregatedKey, + originalKey = resolvedState.originalKey, + indexKey = resolvedState.indexKey, + groupedByPivotKey = resolvedState.groupedByPivotKey, + loading = resolvedState.loading, + pageSize = resolvedState.pageSize, + page = resolvedState.page, + sorted = resolvedState.sorted, + filtered = resolvedState.filtered, + resized = resolvedState.resized, + expanded = resolvedState.expanded, + pages = resolvedState.pages, + onExpandedChange = resolvedState.onExpandedChange, + TableComponent = resolvedState.TableComponent, + TheadComponent = resolvedState.TheadComponent, + TbodyComponent = resolvedState.TbodyComponent, + TrGroupComponent = resolvedState.TrGroupComponent, + TrComponent = resolvedState.TrComponent, + ThComponent = resolvedState.ThComponent, + TdComponent = resolvedState.TdComponent, + TfootComponent = resolvedState.TfootComponent, + PaginationComponent = resolvedState.PaginationComponent, + LoadingComponent = resolvedState.LoadingComponent, + SubComponent = resolvedState.SubComponent, + NoDataComponent = resolvedState.NoDataComponent, + ResizerComponent = resolvedState.ResizerComponent, + ExpanderComponent = resolvedState.ExpanderComponent, + PivotValueComponent = resolvedState.PivotValueComponent, + PivotComponent = resolvedState.PivotComponent, + AggregatedComponent = resolvedState.AggregatedComponent, + FilterComponent = resolvedState.FilterComponent, + PadRowComponent = resolvedState.PadRowComponent, + resolvedData = resolvedState.resolvedData, + allVisibleColumns = resolvedState.allVisibleColumns, + headerGroups = resolvedState.headerGroups, + hasHeaderGroups = resolvedState.hasHeaderGroups, + sortedData = resolvedState.sortedData, + currentlyResizing = resolvedState.currentlyResizing; + + // Pagination + + var startRow = pageSize * page; + var endRow = startRow + pageSize; + var pageRows = manual ? resolvedData : sortedData.slice(startRow, endRow); + var minRows = this.getMinRows(); + var padRows = _.range(Math.max(minRows - pageRows.length, 0)); + + var hasColumnFooter = allVisibleColumns.some(function (d) { + return d.Footer; + }); + var hasFilters = filterable || allVisibleColumns.some(function (d) { + return d.filterable; + }); + + var recurseRowsViewIndex = function recurseRowsViewIndex(rows) { + var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + var index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1; + return [rows.map(function (row, i) { + index += 1; + var rowWithViewIndex = _extends({}, row, { + _viewIndex: index + }); + var newPath = path.concat([i]); + if (rowWithViewIndex[subRowsKey] && _.get(expanded, newPath)) { + var _recurseRowsViewIndex = recurseRowsViewIndex(rowWithViewIndex[subRowsKey], newPath, index); + + var _recurseRowsViewIndex2 = _slicedToArray(_recurseRowsViewIndex, 2); + + rowWithViewIndex[subRowsKey] = _recurseRowsViewIndex2[0]; + index = _recurseRowsViewIndex2[1]; + } + return rowWithViewIndex; + }), index]; + }; + + var _recurseRowsViewIndex3 = recurseRowsViewIndex(pageRows); + + var _recurseRowsViewIndex4 = _slicedToArray(_recurseRowsViewIndex3, 1); + + pageRows = _recurseRowsViewIndex4[0]; + + + var canPrevious = page > 0; + var canNext = page + 1 < pages; + + var rowMinWidth = _.sum(allVisibleColumns.map(function (d) { + var resizedColumn = resized.find(function (x) { + return x.id === d.id; + }) || {}; + return _.getFirstDefined(resizedColumn.value, d.width, d.minWidth); + })); + + var rowIndex = -1; + + var finalState = _extends({}, resolvedState, { + startRow: startRow, + endRow: endRow, + pageRows: pageRows, + minRows: minRows, + padRows: padRows, + hasColumnFooter: hasColumnFooter, + canPrevious: canPrevious, + canNext: canNext, + rowMinWidth: rowMinWidth + }); + + var rootProps = _.splitProps(getProps(finalState, undefined, undefined, this)); + var tableProps = _.splitProps(getTableProps(finalState, undefined, undefined, this)); + var tBodyProps = _.splitProps(getTbodyProps(finalState, undefined, undefined, this)); + var loadingProps = getLoadingProps(finalState, undefined, undefined, this); + var noDataProps = getNoDataProps(finalState, undefined, undefined, this); + + // Visual Components + + var makeHeaderGroup = function makeHeaderGroup(column, i) { + var resizedValue = function resizedValue(col) { + return (resized.find(function (x) { + return x.id === col.id; + }) || {}).value; + }; + var flex = _.sum(column.columns.map(function (col) { + return col.width || resizedValue(col) ? 0 : col.minWidth; + })); + var width = _.sum(column.columns.map(function (col) { + return _.getFirstDefined(resizedValue(col), col.width, col.minWidth); + })); + var maxWidth = _.sum(column.columns.map(function (col) { + return _.getFirstDefined(resizedValue(col), col.width, col.maxWidth); + })); + + var theadGroupThProps = _.splitProps(getTheadGroupThProps(finalState, undefined, column, _this2)); + var columnHeaderProps = _.splitProps(column.getHeaderProps(finalState, undefined, column, _this2)); + + var classes = [column.headerClassName, theadGroupThProps.className, columnHeaderProps.className]; + + var styles = _extends({}, column.headerStyle, theadGroupThProps.style, columnHeaderProps.style); + + var rest = _extends({}, theadGroupThProps.rest, columnHeaderProps.rest); + + var flexStyles = { + flex: flex + ' 0 auto', + width: _.asPx(width), + maxWidth: _.asPx(maxWidth) + }; + + return React.createElement( + ThComponent, + _extends({ + key: i + '-' + column.id, + className: classnames(classes), + style: _extends({}, styles, flexStyles) + }, rest), + _.normalizeComponent(column.Header, { + data: sortedData, + column: column + }) + ); + }; + + var makeHeaderGroups = function makeHeaderGroups() { + var theadGroupProps = _.splitProps(getTheadGroupProps(finalState, undefined, undefined, _this2)); + var theadGroupTrProps = _.splitProps(getTheadGroupTrProps(finalState, undefined, undefined, _this2)); + return React.createElement( + TheadComponent, + _extends({ + className: classnames('-headerGroups', theadGroupProps.className), + style: _extends({}, theadGroupProps.style, { + minWidth: rowMinWidth + 'px' + }) + }, theadGroupProps.rest), + React.createElement( + TrComponent, + _extends({ + className: theadGroupTrProps.className, + style: theadGroupTrProps.style + }, theadGroupTrProps.rest), + headerGroups.map(makeHeaderGroup) + ) + ); + }; + + var makeHeader = function makeHeader(column, i) { + var resizedCol = resized.find(function (x) { + return x.id === column.id; + }) || {}; + var sort = sorted.find(function (d) { + return d.id === column.id; + }); + var show = typeof column.show === 'function' ? column.show() : column.show; + var width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth); + var maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth); + var theadThProps = _.splitProps(getTheadThProps(finalState, undefined, column, _this2)); + var columnHeaderProps = _.splitProps(column.getHeaderProps(finalState, undefined, column, _this2)); + + var classes = [column.headerClassName, theadThProps.className, columnHeaderProps.className]; + + var styles = _extends({}, column.headerStyle, theadThProps.style, columnHeaderProps.style); + + var rest = _extends({}, theadThProps.rest, columnHeaderProps.rest); + + var isResizable = _.getFirstDefined(column.resizable, resizable, false); + var resizer = isResizable ? React.createElement(ResizerComponent, _extends({ + onMouseDown: function onMouseDown(e) { + return _this2.resizeColumnStart(e, column, false); + }, + onTouchStart: function onTouchStart(e) { + return _this2.resizeColumnStart(e, column, true); + } + }, getResizerProps('finalState', undefined, column, _this2))) : null; + + var isSortable = _.getFirstDefined(column.sortable, sortable, false); + + return React.createElement( + ThComponent, + _extends({ + key: i + '-' + column.id, + className: classnames(classes, isResizable && 'rt-resizable-header', sort ? sort.desc ? '-sort-desc' : '-sort-asc' : '', isSortable && '-cursor-pointer', !show && '-hidden', pivotBy && pivotBy.slice(0, -1).includes(column.id) && 'rt-header-pivot'), + style: _extends({}, styles, { + flex: width + ' 0 auto', + width: _.asPx(width), + maxWidth: _.asPx(maxWidth) + }), + toggleSort: function toggleSort(e) { + if (isSortable) _this2.sortColumn(column, multiSort ? e.shiftKey : false); + } + }, rest), + React.createElement( + 'div', + { className: classnames(isResizable && 'rt-resizable-header-content') }, + _.normalizeComponent(column.Header, { + data: sortedData, + column: column + }) + ), + resizer + ); + }; + + var makeHeaders = function makeHeaders() { + var theadProps = _.splitProps(getTheadProps(finalState, undefined, undefined, _this2)); + var theadTrProps = _.splitProps(getTheadTrProps(finalState, undefined, undefined, _this2)); + return React.createElement( + TheadComponent, + _extends({ + className: classnames('-header', theadProps.className), + style: _extends({}, theadProps.style, { + minWidth: rowMinWidth + 'px' + }) + }, theadProps.rest), + React.createElement( + TrComponent, + _extends({ + className: theadTrProps.className, + style: theadTrProps.style + }, theadTrProps.rest), + allVisibleColumns.map(makeHeader) + ) + ); + }; + + var makeFilter = function makeFilter(column, i) { + var resizedCol = resized.find(function (x) { + return x.id === column.id; + }) || {}; + var width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth); + var maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth); + var theadFilterThProps = _.splitProps(getTheadFilterThProps(finalState, undefined, column, _this2)); + var columnHeaderProps = _.splitProps(column.getHeaderProps(finalState, undefined, column, _this2)); + + var classes = [column.headerClassName, theadFilterThProps.className, columnHeaderProps.className]; + + var styles = _extends({}, column.headerStyle, theadFilterThProps.style, columnHeaderProps.style); + + var rest = _extends({}, theadFilterThProps.rest, columnHeaderProps.rest); + + var filter = filtered.find(function (filter) { + return filter.id === column.id; + }); + + var ResolvedFilterComponent = column.Filter || FilterComponent; + + var isFilterable = _.getFirstDefined(column.filterable, filterable, false); + + return React.createElement( + ThComponent, + _extends({ + key: i + '-' + column.id, + className: classnames(classes), + style: _extends({}, styles, { + flex: width + ' 0 auto', + width: _.asPx(width), + maxWidth: _.asPx(maxWidth) + }) + }, rest), + isFilterable ? _.normalizeComponent(ResolvedFilterComponent, { + column: column, + filter: filter, + onChange: function onChange(value) { + return _this2.filterColumn(column, value); + } + }, defaultProps.column.Filter) : null + ); + }; + + var makeFilters = function makeFilters() { + var theadFilterProps = _.splitProps(getTheadFilterProps(finalState, undefined, undefined, _this2)); + var theadFilterTrProps = _.splitProps(getTheadFilterTrProps(finalState, undefined, undefined, _this2)); + return React.createElement( + TheadComponent, + _extends({ + className: classnames('-filters', theadFilterProps.className), + style: _extends({}, theadFilterProps.style, { + minWidth: rowMinWidth + 'px' + }) + }, theadFilterProps.rest), + React.createElement( + TrComponent, + _extends({ + className: theadFilterTrProps.className, + style: theadFilterTrProps.style + }, theadFilterTrProps.rest), + allVisibleColumns.map(makeFilter) + ) + ); + }; + + var makePageRow = function makePageRow(row, i) { + var path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : []; + + var rowInfo = { + original: row[originalKey], + row: row, + index: row[indexKey], + viewIndex: rowIndex += 1, + pageSize: pageSize, + page: page, + level: path.length, + nestingPath: path.concat([i]), + aggregated: row[aggregatedKey], + groupedByPivot: row[groupedByPivotKey], + subRows: row[subRowsKey] + }; + var isExpanded = _.get(expanded, rowInfo.nestingPath); + var trGroupProps = getTrGroupProps(finalState, rowInfo, undefined, _this2); + var trProps = _.splitProps(getTrProps(finalState, rowInfo, undefined, _this2)); + return React.createElement( + TrGroupComponent, + _extends({ key: rowInfo.nestingPath.join('_') }, trGroupProps), + React.createElement( + TrComponent, + _extends({ + className: classnames(trProps.className, row._viewIndex % 2 ? '-even' : '-odd'), + style: trProps.style + }, trProps.rest), + allVisibleColumns.map(function (column, i2) { + var resizedCol = resized.find(function (x) { + return x.id === column.id; + }) || {}; + var show = typeof column.show === 'function' ? column.show() : column.show; + var width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth); + var maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth); + var tdProps = _.splitProps(getTdProps(finalState, rowInfo, column, _this2)); + var columnProps = _.splitProps(column.getProps(finalState, rowInfo, column, _this2)); + + var classes = [tdProps.className, column.className, columnProps.className]; + + var styles = _extends({}, tdProps.style, column.style, columnProps.style); + + var cellInfo = _extends({}, rowInfo, { + isExpanded: isExpanded, + column: _extends({}, column), + value: rowInfo.row[column.id], + pivoted: column.pivoted, + expander: column.expander, + resized: resized, + show: show, + width: width, + maxWidth: maxWidth, + tdProps: tdProps, + columnProps: columnProps, + classes: classes, + styles: styles + }); + + var value = cellInfo.value; + + var useOnExpanderClick = void 0; + var isBranch = void 0; + var isPreview = void 0; + + var onExpanderClick = function onExpanderClick(e) { + var newExpanded = _.clone(expanded); + if (isExpanded) { + newExpanded = _.set(newExpanded, cellInfo.nestingPath, false); + } else { + newExpanded = _.set(newExpanded, cellInfo.nestingPath, {}); + } + + return _this2.setStateWithData({ + expanded: newExpanded + }, function () { + return onExpandedChange && onExpandedChange(newExpanded, cellInfo.nestingPath, e); + }); + }; + + // Default to a standard cell + var resolvedCell = _.normalizeComponent(column.Cell, cellInfo, value); + + // Resolve Renderers + var ResolvedAggregatedComponent = column.Aggregated || (!column.aggregate ? AggregatedComponent : column.Cell); + var ResolvedExpanderComponent = column.Expander || ExpanderComponent; + var ResolvedPivotValueComponent = column.PivotValue || PivotValueComponent; + var DefaultResolvedPivotComponent = PivotComponent || function (props) { + return React.createElement( + 'div', + null, + React.createElement(ResolvedExpanderComponent, props), + React.createElement(ResolvedPivotValueComponent, props) + ); + }; + var ResolvedPivotComponent = column.Pivot || DefaultResolvedPivotComponent; + + // Is this cell expandable? + if (cellInfo.pivoted || cellInfo.expander) { + // Make it expandable by defualt + cellInfo.expandable = true; + useOnExpanderClick = true; + // If pivoted, has no subRows, and does not have a subComponent, + // do not make expandable + if (cellInfo.pivoted && !cellInfo.subRows && !SubComponent) { + cellInfo.expandable = false; + } + } + + if (cellInfo.pivoted) { + // Is this column a branch? + isBranch = rowInfo.row[pivotIDKey] === column.id && cellInfo.subRows; + // Should this column be blank? + isPreview = pivotBy.indexOf(column.id) > pivotBy.indexOf(rowInfo.row[pivotIDKey]) && cellInfo.subRows; + // Pivot Cell Render Override + if (isBranch) { + // isPivot + resolvedCell = _.normalizeComponent(ResolvedPivotComponent, _extends({}, cellInfo, { + value: row[pivotValKey] + }), row[pivotValKey]); + } else if (isPreview) { + // Show the pivot preview + resolvedCell = _.normalizeComponent(ResolvedAggregatedComponent, cellInfo, value); + } else { + resolvedCell = null; + } + } else if (cellInfo.aggregated) { + resolvedCell = _.normalizeComponent(ResolvedAggregatedComponent, cellInfo, value); + } + + if (cellInfo.expander) { + resolvedCell = _.normalizeComponent(ResolvedExpanderComponent, cellInfo, row[pivotValKey]); + if (pivotBy) { + if (cellInfo.groupedByPivot) { + resolvedCell = null; + } + if (!cellInfo.subRows && !SubComponent) { + resolvedCell = null; + } + } + } + + var resolvedOnExpanderClick = useOnExpanderClick ? onExpanderClick : function () {}; + + // If there are multiple onClick events, make sure they don't + // override eachother. This should maybe be expanded to handle all + // function attributes + var interactionProps = { + onClick: resolvedOnExpanderClick + }; + + if (tdProps.rest.onClick) { + interactionProps.onClick = function (e) { + tdProps.rest.onClick(e, function () { + return resolvedOnExpanderClick(e); + }); + }; + } + + if (columnProps.rest.onClick) { + interactionProps.onClick = function (e) { + columnProps.rest.onClick(e, function () { + return resolvedOnExpanderClick(e); + }); + }; + } + + // Return the cell + return React.createElement( + TdComponent + // eslint-disable-next-line react/no-array-index-key + , + _extends({ key: i2 + '-' + column.id, + className: classnames(classes, !show && 'hidden', cellInfo.expandable && 'rt-expandable', (isBranch || isPreview) && 'rt-pivot'), + style: _extends({}, styles, { + flex: width + ' 0 auto', + width: _.asPx(width), + maxWidth: _.asPx(maxWidth) + }) + }, tdProps.rest, columnProps.rest, interactionProps), + resolvedCell + ); + }) + ), + rowInfo.subRows && isExpanded && rowInfo.subRows.map(function (d, i) { + return makePageRow(d, i, rowInfo.nestingPath); + }), + SubComponent && !rowInfo.subRows && isExpanded && SubComponent(rowInfo) + ); + }; + + var makePadColumn = function makePadColumn(column, i) { + var resizedCol = resized.find(function (x) { + return x.id === column.id; + }) || {}; + var show = typeof column.show === 'function' ? column.show() : column.show; + var width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth); + var flex = width; + var maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth); + var tdProps = _.splitProps(getTdProps(finalState, undefined, column, _this2)); + var columnProps = _.splitProps(column.getProps(finalState, undefined, column, _this2)); + + var classes = [tdProps.className, column.className, columnProps.className]; + + var styles = _extends({}, tdProps.style, column.style, columnProps.style); + + return React.createElement( + TdComponent, + _extends({ + key: i + '-' + column.id, + className: classnames(classes, !show && 'hidden'), + style: _extends({}, styles, { + flex: flex + ' 0 auto', + width: _.asPx(width), + maxWidth: _.asPx(maxWidth) + }) + }, tdProps.rest), + _.normalizeComponent(PadRowComponent) + ); + }; + + var makePadRow = function makePadRow(row, i) { + var trGroupProps = getTrGroupProps(finalState, undefined, undefined, _this2); + var trProps = _.splitProps(getTrProps(finalState, undefined, undefined, _this2)); + return React.createElement( + TrGroupComponent, + _extends({ key: 'pad-' + i }, trGroupProps), + React.createElement( + TrComponent, + { + className: classnames('-padRow', (pageRows.length + i) % 2 ? '-even' : '-odd', trProps.className), + style: trProps.style || {} + }, + allVisibleColumns.map(makePadColumn) + ) + ); + }; + + var makeColumnFooter = function makeColumnFooter(column, i) { + var resizedCol = resized.find(function (x) { + return x.id === column.id; + }) || {}; + var show = typeof column.show === 'function' ? column.show() : column.show; + var width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth); + var maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth); + var tFootTdProps = _.splitProps(getTfootTdProps(finalState, undefined, undefined, _this2)); + var columnProps = _.splitProps(column.getProps(finalState, undefined, column, _this2)); + var columnFooterProps = _.splitProps(column.getFooterProps(finalState, undefined, column, _this2)); + + var classes = [tFootTdProps.className, column.className, columnProps.className, columnFooterProps.className]; + + var styles = _extends({}, tFootTdProps.style, column.style, columnProps.style, columnFooterProps.style); + + return React.createElement( + TdComponent, + _extends({ + key: i + '-' + column.id, + className: classnames(classes, !show && 'hidden'), + style: _extends({}, styles, { + flex: width + ' 0 auto', + width: _.asPx(width), + maxWidth: _.asPx(maxWidth) + }) + }, columnProps.rest, tFootTdProps.rest, columnFooterProps.rest), + _.normalizeComponent(column.Footer, { + data: sortedData, + column: column + }) + ); + }; + + var makeColumnFooters = function makeColumnFooters() { + var tFootProps = getTfootProps(finalState, undefined, undefined, _this2); + var tFootTrProps = _.splitProps(getTfootTrProps(finalState, undefined, undefined, _this2)); + return React.createElement( + TfootComponent, + _extends({ + className: tFootProps.className, + style: _extends({}, tFootProps.style, { + minWidth: rowMinWidth + 'px' + }) + }, tFootProps.rest), + React.createElement( + TrComponent, + _extends({ + className: classnames(tFootTrProps.className), + style: tFootTrProps.style + }, tFootTrProps.rest), + allVisibleColumns.map(makeColumnFooter) + ) + ); + }; + + var makePagination = function makePagination() { + var paginationProps = _.splitProps(getPaginationProps(finalState, undefined, undefined, _this2)); + return React.createElement(PaginationComponent, _extends({}, resolvedState, { + pages: pages, + canPrevious: canPrevious, + canNext: canNext, + onPageChange: _this2.onPageChange, + onPageSizeChange: _this2.onPageSizeChange, + className: paginationProps.className, + style: paginationProps.style + }, paginationProps.rest)); + }; + + var makeTable = function makeTable() { + var pagination = makePagination(); + return React.createElement( + 'div', + _extends({ + className: classnames('ReactTable', className, rootProps.className), + style: _extends({}, style, rootProps.style) + }, rootProps.rest), + showPagination && showPaginationTop ? React.createElement( + 'div', + { className: 'pagination-top' }, + pagination + ) : null, + React.createElement( + TableComponent, + _extends({ + className: classnames(tableProps.className, currentlyResizing ? 'rt-resizing' : ''), + style: tableProps.style + }, tableProps.rest), + hasHeaderGroups ? makeHeaderGroups() : null, + makeHeaders(), + hasFilters ? makeFilters() : null, + React.createElement( + TbodyComponent, + _extends({ + className: classnames(tBodyProps.className), + style: _extends({}, tBodyProps.style, { + minWidth: rowMinWidth + 'px' + }) + }, tBodyProps.rest), + pageRows.map(function (d, i) { + return makePageRow(d, i); + }), + padRows.map(makePadRow) + ), + hasColumnFooter ? makeColumnFooters() : null + ), + showPagination && showPaginationBottom ? React.createElement( + 'div', + { className: 'pagination-bottom' }, + pagination + ) : null, + !pageRows.length && React.createElement( + NoDataComponent, + noDataProps, + _.normalizeComponent(noDataText) + ), + React.createElement(LoadingComponent, _extends({ loading: loading, loadingText: loadingText }, loadingProps)) + ); + }; + + // childProps are optionally passed to a function-as-a-child + return children ? children(finalState, makeTable, this) : makeTable(); + } + }]); + + return ReactTable; +}(Methods(Lifecycle(Component))); + +ReactTable.propTypes = propTypes; +ReactTable.defaultProps = defaultProps; +export default ReactTable; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/index.js"],"names":["React","Component","classnames","_","Lifecycle","Methods","defaultProps","propTypes","ReactTableDefaults","ReactTable","props","getResolvedState","bind","getDataModel","getSortedData","fireFetchData","getPropOrState","getStateOrProp","filterData","sortData","getMinRows","onPageChange","onPageSizeChange","sortColumn","filterColumn","resizeColumnStart","resizeColumnEnd","resizeColumnMoving","state","page","defaultPage","pageSize","defaultPageSize","sorted","defaultSorted","expanded","defaultExpanded","filtered","defaultFiltered","resized","defaultResized","currentlyResizing","skipNextSort","resolvedState","children","className","style","getProps","getTableProps","getTheadGroupProps","getTheadGroupTrProps","getTheadGroupThProps","getTheadProps","getTheadTrProps","getTheadThProps","getTheadFilterProps","getTheadFilterTrProps","getTheadFilterThProps","getTbodyProps","getTrGroupProps","getTrProps","getTdProps","getTfootProps","getTfootTrProps","getTfootTdProps","getPaginationProps","getLoadingProps","getNoDataProps","getResizerProps","showPagination","showPaginationTop","showPaginationBottom","manual","loadingText","noDataText","sortable","multiSort","resizable","filterable","pivotIDKey","pivotValKey","pivotBy","subRowsKey","aggregatedKey","originalKey","indexKey","groupedByPivotKey","loading","pages","onExpandedChange","TableComponent","TheadComponent","TbodyComponent","TrGroupComponent","TrComponent","ThComponent","TdComponent","TfootComponent","PaginationComponent","LoadingComponent","SubComponent","NoDataComponent","ResizerComponent","ExpanderComponent","PivotValueComponent","PivotComponent","AggregatedComponent","FilterComponent","PadRowComponent","resolvedData","allVisibleColumns","headerGroups","hasHeaderGroups","sortedData","startRow","endRow","pageRows","slice","minRows","padRows","range","Math","max","length","hasColumnFooter","some","d","Footer","hasFilters","recurseRowsViewIndex","rows","path","index","map","row","i","rowWithViewIndex","_viewIndex","newPath","concat","get","canPrevious","canNext","rowMinWidth","sum","resizedColumn","find","x","id","getFirstDefined","value","width","minWidth","rowIndex","finalState","rootProps","splitProps","undefined","tableProps","tBodyProps","loadingProps","noDataProps","makeHeaderGroup","column","resizedValue","col","flex","columns","maxWidth","theadGroupThProps","columnHeaderProps","getHeaderProps","classes","headerClassName","styles","headerStyle","rest","flexStyles","asPx","normalizeComponent","Header","data","makeHeaderGroups","theadGroupProps","theadGroupTrProps","makeHeader","resizedCol","sort","show","theadThProps","isResizable","resizer","e","isSortable","desc","includes","shiftKey","makeHeaders","theadProps","theadTrProps","makeFilter","theadFilterThProps","filter","ResolvedFilterComponent","Filter","isFilterable","onChange","makeFilters","theadFilterProps","theadFilterTrProps","makePageRow","rowInfo","original","viewIndex","level","nestingPath","aggregated","groupedByPivot","subRows","isExpanded","trGroupProps","trProps","join","i2","tdProps","columnProps","cellInfo","pivoted","expander","useOnExpanderClick","isBranch","isPreview","onExpanderClick","newExpanded","clone","set","setStateWithData","resolvedCell","Cell","ResolvedAggregatedComponent","Aggregated","aggregate","ResolvedExpanderComponent","Expander","ResolvedPivotValueComponent","PivotValue","DefaultResolvedPivotComponent","ResolvedPivotComponent","Pivot","expandable","indexOf","resolvedOnExpanderClick","interactionProps","onClick","makePadColumn","makePadRow","makeColumnFooter","tFootTdProps","columnFooterProps","getFooterProps","makeColumnFooters","tFootProps","tFootTrProps","makePagination","paginationProps","makeTable","pagination"],"mappings":"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","file":"index.js","sourcesContent":["import React, { Component } from 'react'\nimport classnames from 'classnames'\n//\nimport _ from './utils'\nimport Lifecycle from './lifecycle'\nimport Methods from './methods'\nimport defaultProps from './defaultProps'\nimport propTypes from './propTypes'\n\nexport const ReactTableDefaults = defaultProps\n\nexport default class ReactTable extends Methods(Lifecycle(Component)) {\n  static propTypes = propTypes\n  static defaultProps = defaultProps\n\n  constructor (props) {\n    super()\n\n    this.getResolvedState = this.getResolvedState.bind(this)\n    this.getDataModel = this.getDataModel.bind(this)\n    this.getSortedData = this.getSortedData.bind(this)\n    this.fireFetchData = this.fireFetchData.bind(this)\n    this.getPropOrState = this.getPropOrState.bind(this)\n    this.getStateOrProp = this.getStateOrProp.bind(this)\n    this.filterData = this.filterData.bind(this)\n    this.sortData = this.sortData.bind(this)\n    this.getMinRows = this.getMinRows.bind(this)\n    this.onPageChange = this.onPageChange.bind(this)\n    this.onPageSizeChange = this.onPageSizeChange.bind(this)\n    this.sortColumn = this.sortColumn.bind(this)\n    this.filterColumn = this.filterColumn.bind(this)\n    this.resizeColumnStart = this.resizeColumnStart.bind(this)\n    this.resizeColumnEnd = this.resizeColumnEnd.bind(this)\n    this.resizeColumnMoving = this.resizeColumnMoving.bind(this)\n\n    this.state = {\n      page: props.defaultPage,\n      pageSize: props.defaultPageSize,\n      sorted: props.defaultSorted,\n      expanded: props.defaultExpanded,\n      filtered: props.defaultFiltered,\n      resized: props.defaultResized,\n      currentlyResizing: false,\n      skipNextSort: false,\n    }\n  }\n\n  render () {\n    const resolvedState = this.getResolvedState()\n    const {\n      children,\n      className,\n      style,\n      getProps,\n      getTableProps,\n      getTheadGroupProps,\n      getTheadGroupTrProps,\n      getTheadGroupThProps,\n      getTheadProps,\n      getTheadTrProps,\n      getTheadThProps,\n      getTheadFilterProps,\n      getTheadFilterTrProps,\n      getTheadFilterThProps,\n      getTbodyProps,\n      getTrGroupProps,\n      getTrProps,\n      getTdProps,\n      getTfootProps,\n      getTfootTrProps,\n      getTfootTdProps,\n      getPaginationProps,\n      getLoadingProps,\n      getNoDataProps,\n      getResizerProps,\n      showPagination,\n      showPaginationTop,\n      showPaginationBottom,\n      manual,\n      loadingText,\n      noDataText,\n      sortable,\n      multiSort,\n      resizable,\n      filterable,\n      // Pivoting State\n      pivotIDKey,\n      pivotValKey,\n      pivotBy,\n      subRowsKey,\n      aggregatedKey,\n      originalKey,\n      indexKey,\n      groupedByPivotKey,\n      // State\n      loading,\n      pageSize,\n      page,\n      sorted,\n      filtered,\n      resized,\n      expanded,\n      pages,\n      onExpandedChange,\n      // Components\n      TableComponent,\n      TheadComponent,\n      TbodyComponent,\n      TrGroupComponent,\n      TrComponent,\n      ThComponent,\n      TdComponent,\n      TfootComponent,\n      PaginationComponent,\n      LoadingComponent,\n      SubComponent,\n      NoDataComponent,\n      ResizerComponent,\n      ExpanderComponent,\n      PivotValueComponent,\n      PivotComponent,\n      AggregatedComponent,\n      FilterComponent,\n      PadRowComponent,\n      // Data model\n      resolvedData,\n      allVisibleColumns,\n      headerGroups,\n      hasHeaderGroups,\n      // Sorted Data\n      sortedData,\n      currentlyResizing,\n    } = resolvedState\n\n    // Pagination\n    const startRow = pageSize * page\n    const endRow = startRow + pageSize\n    let pageRows = manual ? resolvedData : sortedData.slice(startRow, endRow)\n    const minRows = this.getMinRows()\n    const padRows = _.range(Math.max(minRows - pageRows.length, 0))\n\n    const hasColumnFooter = allVisibleColumns.some(d => d.Footer)\n    const hasFilters = filterable || allVisibleColumns.some(d => d.filterable)\n\n    const recurseRowsViewIndex = (rows, path = [], index = -1) => [\n      rows.map((row, i) => {\n        index += 1\n        const rowWithViewIndex = {\n          ...row,\n          _viewIndex: index,\n        }\n        const newPath = path.concat([i])\n        if (rowWithViewIndex[subRowsKey] && _.get(expanded, newPath)) {\n          [rowWithViewIndex[subRowsKey], index] = recurseRowsViewIndex(\n            rowWithViewIndex[subRowsKey],\n            newPath,\n            index\n          )\n        }\n        return rowWithViewIndex\n      }),\n      index,\n    ];\n    [pageRows] = recurseRowsViewIndex(pageRows)\n\n    const canPrevious = page > 0\n    const canNext = page + 1 < pages\n\n    const rowMinWidth = _.sum(\n      allVisibleColumns.map(d => {\n        const resizedColumn = resized.find(x => x.id === d.id) || {}\n        return _.getFirstDefined(resizedColumn.value, d.width, d.minWidth)\n      })\n    )\n\n    let rowIndex = -1\n\n    const finalState = {\n      ...resolvedState,\n      startRow,\n      endRow,\n      pageRows,\n      minRows,\n      padRows,\n      hasColumnFooter,\n      canPrevious,\n      canNext,\n      rowMinWidth,\n    }\n\n    const rootProps = _.splitProps(getProps(finalState, undefined, undefined, this))\n    const tableProps = _.splitProps(getTableProps(finalState, undefined, undefined, this))\n    const tBodyProps = _.splitProps(getTbodyProps(finalState, undefined, undefined, this))\n    const loadingProps = getLoadingProps(finalState, undefined, undefined, this)\n    const noDataProps = getNoDataProps(finalState, undefined, undefined, this)\n\n    // Visual Components\n\n    const makeHeaderGroup = (column, i) => {\n      const resizedValue = col => (resized.find(x => x.id === col.id) || {}).value\n      const flex = _.sum(\n        column.columns.map(col => (col.width || resizedValue(col) ? 0 : col.minWidth))\n      )\n      const width = _.sum(\n        column.columns.map(col => _.getFirstDefined(resizedValue(col), col.width, col.minWidth))\n      )\n      const maxWidth = _.sum(\n        column.columns.map(col => _.getFirstDefined(resizedValue(col), col.width, col.maxWidth))\n      )\n\n      const theadGroupThProps = _.splitProps(\n        getTheadGroupThProps(finalState, undefined, column, this)\n      )\n      const columnHeaderProps = _.splitProps(\n        column.getHeaderProps(finalState, undefined, column, this)\n      )\n\n      const classes = [\n        column.headerClassName,\n        theadGroupThProps.className,\n        columnHeaderProps.className,\n      ]\n\n      const styles = {\n        ...column.headerStyle,\n        ...theadGroupThProps.style,\n        ...columnHeaderProps.style,\n      }\n\n      const rest = {\n        ...theadGroupThProps.rest,\n        ...columnHeaderProps.rest,\n      }\n\n      const flexStyles = {\n        flex: `${flex} 0 auto`,\n        width: _.asPx(width),\n        maxWidth: _.asPx(maxWidth),\n      }\n\n      return (\n        <ThComponent\n          key={`${i}-${column.id}`}\n          className={classnames(classes)}\n          style={{\n            ...styles,\n            ...flexStyles,\n          }}\n          {...rest}\n        >\n          {_.normalizeComponent(column.Header, {\n            data: sortedData,\n            column,\n          })}\n        </ThComponent>\n      )\n    }\n\n    const makeHeaderGroups = () => {\n      const theadGroupProps = _.splitProps(\n        getTheadGroupProps(finalState, undefined, undefined, this)\n      )\n      const theadGroupTrProps = _.splitProps(\n        getTheadGroupTrProps(finalState, undefined, undefined, this)\n      )\n      return (\n        <TheadComponent\n          className={classnames('-headerGroups', theadGroupProps.className)}\n          style={{\n            ...theadGroupProps.style,\n            minWidth: `${rowMinWidth}px`,\n          }}\n          {...theadGroupProps.rest}\n        >\n          <TrComponent\n            className={theadGroupTrProps.className}\n            style={theadGroupTrProps.style}\n            {...theadGroupTrProps.rest}\n          >\n            {headerGroups.map(makeHeaderGroup)}\n          </TrComponent>\n        </TheadComponent>\n      )\n    }\n\n    const makeHeader = (column, i) => {\n      const resizedCol = resized.find(x => x.id === column.id) || {}\n      const sort = sorted.find(d => d.id === column.id)\n      const show = typeof column.show === 'function' ? column.show() : column.show\n      const width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth)\n      const maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth)\n      const theadThProps = _.splitProps(getTheadThProps(finalState, undefined, column, this))\n      const columnHeaderProps = _.splitProps(\n        column.getHeaderProps(finalState, undefined, column, this)\n      )\n\n      const classes = [column.headerClassName, theadThProps.className, columnHeaderProps.className]\n\n      const styles = {\n        ...column.headerStyle,\n        ...theadThProps.style,\n        ...columnHeaderProps.style,\n      }\n\n      const rest = {\n        ...theadThProps.rest,\n        ...columnHeaderProps.rest,\n      }\n\n      const isResizable = _.getFirstDefined(column.resizable, resizable, false)\n      const resizer = isResizable ? (\n        <ResizerComponent\n          onMouseDown={e => this.resizeColumnStart(e, column, false)}\n          onTouchStart={e => this.resizeColumnStart(e, column, true)}\n          {...getResizerProps('finalState', undefined, column, this)}\n        />\n      ) : null\n\n      const isSortable = _.getFirstDefined(column.sortable, sortable, false)\n\n      return (\n        <ThComponent\n          key={`${i}-${column.id}`}\n          className={classnames(\n            classes,\n            isResizable && 'rt-resizable-header',\n            sort ? (sort.desc ? '-sort-desc' : '-sort-asc') : '',\n            isSortable && '-cursor-pointer',\n            !show && '-hidden',\n            pivotBy && pivotBy.slice(0, -1).includes(column.id) && 'rt-header-pivot'\n          )}\n          style={{\n            ...styles,\n            flex: `${width} 0 auto`,\n            width: _.asPx(width),\n            maxWidth: _.asPx(maxWidth),\n          }}\n          toggleSort={e => {\n            if (isSortable) this.sortColumn(column, multiSort ? e.shiftKey : false)\n          }}\n          {...rest}\n        >\n          <div className={classnames(isResizable && 'rt-resizable-header-content')}>\n            {_.normalizeComponent(column.Header, {\n              data: sortedData,\n              column,\n            })}\n          </div>\n          {resizer}\n        </ThComponent>\n      )\n    }\n\n    const makeHeaders = () => {\n      const theadProps = _.splitProps(getTheadProps(finalState, undefined, undefined, this))\n      const theadTrProps = _.splitProps(getTheadTrProps(finalState, undefined, undefined, this))\n      return (\n        <TheadComponent\n          className={classnames('-header', theadProps.className)}\n          style={{\n            ...theadProps.style,\n            minWidth: `${rowMinWidth}px`,\n          }}\n          {...theadProps.rest}\n        >\n          <TrComponent\n            className={theadTrProps.className}\n            style={theadTrProps.style}\n            {...theadTrProps.rest}\n          >\n            {allVisibleColumns.map(makeHeader)}\n          </TrComponent>\n        </TheadComponent>\n      )\n    }\n\n    const makeFilter = (column, i) => {\n      const resizedCol = resized.find(x => x.id === column.id) || {}\n      const width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth)\n      const maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth)\n      const theadFilterThProps = _.splitProps(\n        getTheadFilterThProps(finalState, undefined, column, this)\n      )\n      const columnHeaderProps = _.splitProps(\n        column.getHeaderProps(finalState, undefined, column, this)\n      )\n\n      const classes = [\n        column.headerClassName,\n        theadFilterThProps.className,\n        columnHeaderProps.className,\n      ]\n\n      const styles = {\n        ...column.headerStyle,\n        ...theadFilterThProps.style,\n        ...columnHeaderProps.style,\n      }\n\n      const rest = {\n        ...theadFilterThProps.rest,\n        ...columnHeaderProps.rest,\n      }\n\n      const filter = filtered.find(filter => filter.id === column.id)\n\n      const ResolvedFilterComponent = column.Filter || FilterComponent\n\n      const isFilterable = _.getFirstDefined(column.filterable, filterable, false)\n\n      return (\n        <ThComponent\n          key={`${i}-${column.id}`}\n          className={classnames(classes)}\n          style={{\n            ...styles,\n            flex: `${width} 0 auto`,\n            width: _.asPx(width),\n            maxWidth: _.asPx(maxWidth),\n          }}\n          {...rest}\n        >\n          {isFilterable\n            ? _.normalizeComponent(\n                ResolvedFilterComponent,\n                {\n                  column,\n                  filter,\n                  onChange: value => this.filterColumn(column, value),\n                },\n                defaultProps.column.Filter\n              )\n            : null}\n        </ThComponent>\n      )\n    }\n\n    const makeFilters = () => {\n      const theadFilterProps = _.splitProps(\n        getTheadFilterProps(finalState, undefined, undefined, this)\n      )\n      const theadFilterTrProps = _.splitProps(\n        getTheadFilterTrProps(finalState, undefined, undefined, this)\n      )\n      return (\n        <TheadComponent\n          className={classnames('-filters', theadFilterProps.className)}\n          style={{\n            ...theadFilterProps.style,\n            minWidth: `${rowMinWidth}px`,\n          }}\n          {...theadFilterProps.rest}\n        >\n          <TrComponent\n            className={theadFilterTrProps.className}\n            style={theadFilterTrProps.style}\n            {...theadFilterTrProps.rest}\n          >\n            {allVisibleColumns.map(makeFilter)}\n          </TrComponent>\n        </TheadComponent>\n      )\n    }\n\n    const makePageRow = (row, i, path = []) => {\n      const rowInfo = {\n        original: row[originalKey],\n        row,\n        index: row[indexKey],\n        viewIndex: (rowIndex += 1),\n        pageSize,\n        page,\n        level: path.length,\n        nestingPath: path.concat([i]),\n        aggregated: row[aggregatedKey],\n        groupedByPivot: row[groupedByPivotKey],\n        subRows: row[subRowsKey],\n      }\n      const isExpanded = _.get(expanded, rowInfo.nestingPath)\n      const trGroupProps = getTrGroupProps(finalState, rowInfo, undefined, this)\n      const trProps = _.splitProps(getTrProps(finalState, rowInfo, undefined, this))\n      return (\n        <TrGroupComponent key={rowInfo.nestingPath.join('_')} {...trGroupProps}>\n          <TrComponent\n            className={classnames(trProps.className, row._viewIndex % 2 ? '-even' : '-odd')}\n            style={trProps.style}\n            {...trProps.rest}\n          >\n            {allVisibleColumns.map((column, i2) => {\n              const resizedCol = resized.find(x => x.id === column.id) || {}\n              const show = typeof column.show === 'function' ? column.show() : column.show\n              const width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth)\n              const maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth)\n              const tdProps = _.splitProps(getTdProps(finalState, rowInfo, column, this))\n              const columnProps = _.splitProps(column.getProps(finalState, rowInfo, column, this))\n\n              const classes = [tdProps.className, column.className, columnProps.className]\n\n              const styles = {\n                ...tdProps.style,\n                ...column.style,\n                ...columnProps.style,\n              }\n\n              const cellInfo = {\n                ...rowInfo,\n                isExpanded,\n                column: { ...column },\n                value: rowInfo.row[column.id],\n                pivoted: column.pivoted,\n                expander: column.expander,\n                resized,\n                show,\n                width,\n                maxWidth,\n                tdProps,\n                columnProps,\n                classes,\n                styles,\n              }\n\n              const value = cellInfo.value\n\n              let useOnExpanderClick\n              let isBranch\n              let isPreview\n\n              const onExpanderClick = e => {\n                let newExpanded = _.clone(expanded)\n                if (isExpanded) {\n                  newExpanded = _.set(newExpanded, cellInfo.nestingPath, false)\n                } else {\n                  newExpanded = _.set(newExpanded, cellInfo.nestingPath, {})\n                }\n\n                return this.setStateWithData(\n                  {\n                    expanded: newExpanded,\n                  },\n                  () => onExpandedChange && onExpandedChange(newExpanded, cellInfo.nestingPath, e)\n                )\n              }\n\n              // Default to a standard cell\n              let resolvedCell = _.normalizeComponent(column.Cell, cellInfo, value)\n\n              // Resolve Renderers\n              const ResolvedAggregatedComponent =\n                column.Aggregated || (!column.aggregate ? AggregatedComponent : column.Cell)\n              const ResolvedExpanderComponent = column.Expander || ExpanderComponent\n              const ResolvedPivotValueComponent = column.PivotValue || PivotValueComponent\n              const DefaultResolvedPivotComponent =\n                PivotComponent ||\n                (props => (\n                  <div>\n                    <ResolvedExpanderComponent {...props} />\n                    <ResolvedPivotValueComponent {...props} />\n                  </div>\n                ))\n              const ResolvedPivotComponent = column.Pivot || DefaultResolvedPivotComponent\n\n              // Is this cell expandable?\n              if (cellInfo.pivoted || cellInfo.expander) {\n                // Make it expandable by defualt\n                cellInfo.expandable = true\n                useOnExpanderClick = true\n                // If pivoted, has no subRows, and does not have a subComponent,\n                // do not make expandable\n                if (cellInfo.pivoted && !cellInfo.subRows && !SubComponent) {\n                  cellInfo.expandable = false\n                }\n              }\n\n              if (cellInfo.pivoted) {\n                // Is this column a branch?\n                isBranch = rowInfo.row[pivotIDKey] === column.id && cellInfo.subRows\n                // Should this column be blank?\n                isPreview =\n                  pivotBy.indexOf(column.id) > pivotBy.indexOf(rowInfo.row[pivotIDKey]) &&\n                  cellInfo.subRows\n                // Pivot Cell Render Override\n                if (isBranch) {\n                  // isPivot\n                  resolvedCell = _.normalizeComponent(\n                    ResolvedPivotComponent,\n                    {\n                      ...cellInfo,\n                      value: row[pivotValKey],\n                    },\n                    row[pivotValKey]\n                  )\n                } else if (isPreview) {\n                  // Show the pivot preview\n                  resolvedCell = _.normalizeComponent(ResolvedAggregatedComponent, cellInfo, value)\n                } else {\n                  resolvedCell = null\n                }\n              } else if (cellInfo.aggregated) {\n                resolvedCell = _.normalizeComponent(ResolvedAggregatedComponent, cellInfo, value)\n              }\n\n              if (cellInfo.expander) {\n                resolvedCell = _.normalizeComponent(\n                  ResolvedExpanderComponent,\n                  cellInfo,\n                  row[pivotValKey]\n                )\n                if (pivotBy) {\n                  if (cellInfo.groupedByPivot) {\n                    resolvedCell = null\n                  }\n                  if (!cellInfo.subRows && !SubComponent) {\n                    resolvedCell = null\n                  }\n                }\n              }\n\n              const resolvedOnExpanderClick = useOnExpanderClick ? onExpanderClick : () => {}\n\n              // If there are multiple onClick events, make sure they don't\n              // override eachother. This should maybe be expanded to handle all\n              // function attributes\n              const interactionProps = {\n                onClick: resolvedOnExpanderClick,\n              }\n\n              if (tdProps.rest.onClick) {\n                interactionProps.onClick = e => {\n                  tdProps.rest.onClick(e, () => resolvedOnExpanderClick(e))\n                }\n              }\n\n              if (columnProps.rest.onClick) {\n                interactionProps.onClick = e => {\n                  columnProps.rest.onClick(e, () => resolvedOnExpanderClick(e))\n                }\n              }\n\n              // Return the cell\n              return (\n                <TdComponent\n                  // eslint-disable-next-line react/no-array-index-key\n                  key={`${i2}-${column.id}`}\n                  className={classnames(\n                    classes,\n                    !show && 'hidden',\n                    cellInfo.expandable && 'rt-expandable',\n                    (isBranch || isPreview) && 'rt-pivot'\n                  )}\n                  style={{\n                    ...styles,\n                    flex: `${width} 0 auto`,\n                    width: _.asPx(width),\n                    maxWidth: _.asPx(maxWidth),\n                  }}\n                  {...tdProps.rest}\n                  {...columnProps.rest}\n                  {...interactionProps}\n                >\n                  {resolvedCell}\n                </TdComponent>\n              )\n            })}\n          </TrComponent>\n          {rowInfo.subRows &&\n            isExpanded &&\n            rowInfo.subRows.map((d, i) => makePageRow(d, i, rowInfo.nestingPath))}\n          {SubComponent && !rowInfo.subRows && isExpanded && SubComponent(rowInfo)}\n        </TrGroupComponent>\n      )\n    }\n\n    const makePadColumn = (column, i) => {\n      const resizedCol = resized.find(x => x.id === column.id) || {}\n      const show = typeof column.show === 'function' ? column.show() : column.show\n      const width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth)\n      const flex = width\n      const maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth)\n      const tdProps = _.splitProps(getTdProps(finalState, undefined, column, this))\n      const columnProps = _.splitProps(column.getProps(finalState, undefined, column, this))\n\n      const classes = [tdProps.className, column.className, columnProps.className]\n\n      const styles = {\n        ...tdProps.style,\n        ...column.style,\n        ...columnProps.style,\n      }\n\n      return (\n        <TdComponent\n          key={`${i}-${column.id}`}\n          className={classnames(classes, !show && 'hidden')}\n          style={{\n            ...styles,\n            flex: `${flex} 0 auto`,\n            width: _.asPx(width),\n            maxWidth: _.asPx(maxWidth),\n          }}\n          {...tdProps.rest}\n        >\n          {_.normalizeComponent(PadRowComponent)}\n        </TdComponent>\n      )\n    }\n\n    const makePadRow = (row, i) => {\n      const trGroupProps = getTrGroupProps(finalState, undefined, undefined, this)\n      const trProps = _.splitProps(getTrProps(finalState, undefined, undefined, this))\n      return (\n        <TrGroupComponent key={`pad-${i}`} {...trGroupProps}>\n          <TrComponent\n            className={classnames(\n              '-padRow',\n              (pageRows.length + i) % 2 ? '-even' : '-odd',\n              trProps.className\n            )}\n            style={trProps.style || {}}\n          >\n            {allVisibleColumns.map(makePadColumn)}\n          </TrComponent>\n        </TrGroupComponent>\n      )\n    }\n\n    const makeColumnFooter = (column, i) => {\n      const resizedCol = resized.find(x => x.id === column.id) || {}\n      const show = typeof column.show === 'function' ? column.show() : column.show\n      const width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth)\n      const maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth)\n      const tFootTdProps = _.splitProps(getTfootTdProps(finalState, undefined, undefined, this))\n      const columnProps = _.splitProps(column.getProps(finalState, undefined, column, this))\n      const columnFooterProps = _.splitProps(\n        column.getFooterProps(finalState, undefined, column, this)\n      )\n\n      const classes = [\n        tFootTdProps.className,\n        column.className,\n        columnProps.className,\n        columnFooterProps.className,\n      ]\n\n      const styles = {\n        ...tFootTdProps.style,\n        ...column.style,\n        ...columnProps.style,\n        ...columnFooterProps.style,\n      }\n\n      return (\n        <TdComponent\n          key={`${i}-${column.id}`}\n          className={classnames(classes, !show && 'hidden')}\n          style={{\n            ...styles,\n            flex: `${width} 0 auto`,\n            width: _.asPx(width),\n            maxWidth: _.asPx(maxWidth),\n          }}\n          {...columnProps.rest}\n          {...tFootTdProps.rest}\n          {...columnFooterProps.rest}\n        >\n          {_.normalizeComponent(column.Footer, {\n            data: sortedData,\n            column,\n          })}\n        </TdComponent>\n      )\n    }\n\n    const makeColumnFooters = () => {\n      const tFootProps = getTfootProps(finalState, undefined, undefined, this)\n      const tFootTrProps = _.splitProps(getTfootTrProps(finalState, undefined, undefined, this))\n      return (\n        <TfootComponent\n          className={tFootProps.className}\n          style={{\n            ...tFootProps.style,\n            minWidth: `${rowMinWidth}px`,\n          }}\n          {...tFootProps.rest}\n        >\n          <TrComponent\n            className={classnames(tFootTrProps.className)}\n            style={tFootTrProps.style}\n            {...tFootTrProps.rest}\n          >\n            {allVisibleColumns.map(makeColumnFooter)}\n          </TrComponent>\n        </TfootComponent>\n      )\n    }\n\n    const makePagination = () => {\n      const paginationProps = _.splitProps(\n        getPaginationProps(finalState, undefined, undefined, this)\n      )\n      return (\n        <PaginationComponent\n          {...resolvedState}\n          pages={pages}\n          canPrevious={canPrevious}\n          canNext={canNext}\n          onPageChange={this.onPageChange}\n          onPageSizeChange={this.onPageSizeChange}\n          className={paginationProps.className}\n          style={paginationProps.style}\n          {...paginationProps.rest}\n        />\n      )\n    }\n\n    const makeTable = () => {\n      const pagination = makePagination()\n      return (\n        <div\n          className={classnames('ReactTable', className, rootProps.className)}\n          style={{\n            ...style,\n            ...rootProps.style,\n          }}\n          {...rootProps.rest}\n        >\n          {showPagination && showPaginationTop ? (\n            <div className=\"pagination-top\">{pagination}</div>\n          ) : null}\n          <TableComponent\n            className={classnames(tableProps.className, currentlyResizing ? 'rt-resizing' : '')}\n            style={tableProps.style}\n            {...tableProps.rest}\n          >\n            {hasHeaderGroups ? makeHeaderGroups() : null}\n            {makeHeaders()}\n            {hasFilters ? makeFilters() : null}\n            <TbodyComponent\n              className={classnames(tBodyProps.className)}\n              style={{\n                ...tBodyProps.style,\n                minWidth: `${rowMinWidth}px`,\n              }}\n              {...tBodyProps.rest}\n            >\n              {pageRows.map((d, i) => makePageRow(d, i))}\n              {padRows.map(makePadRow)}\n            </TbodyComponent>\n            {hasColumnFooter ? makeColumnFooters() : null}\n          </TableComponent>\n          {showPagination && showPaginationBottom ? (\n            <div className=\"pagination-bottom\">{pagination}</div>\n          ) : null}\n          {!pageRows.length && (\n            <NoDataComponent {...noDataProps}>{_.normalizeComponent(noDataText)}</NoDataComponent>\n          )}\n          <LoadingComponent loading={loading} loadingText={loadingText} {...loadingProps} />\n        </div>\n      )\n    }\n\n    // childProps are optionally passed to a function-as-a-child\n    return children ? children(finalState, makeTable, this) : makeTable()\n  }\n}\n"]} \ No newline at end of file diff --git a/es/lifecycle.js b/es/lifecycle.js new file mode 100644 index 0000000000..b05833f4eb --- /dev/null +++ b/es/lifecycle.js @@ -0,0 +1,125 @@ +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; }; }(); + +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; } + +export default (function (Base) { + return function (_Base) { + _inherits(_class, _Base); + + function _class() { + _classCallCheck(this, _class); + + return _possibleConstructorReturn(this, (_class.__proto__ || Object.getPrototypeOf(_class)).apply(this, arguments)); + } + + _createClass(_class, [{ + key: 'componentWillMount', + value: function componentWillMount() { + this.setStateWithData(this.getDataModel(this.getResolvedState(), true)); + } + }, { + key: 'componentDidMount', + value: function componentDidMount() { + this.fireFetchData(); + } + }, { + key: 'componentWillReceiveProps', + value: function componentWillReceiveProps(nextProps, nextState) { + var oldState = this.getResolvedState(); + var newState = this.getResolvedState(nextProps, nextState); + + // Do a deep compare of new and old `defaultOption` and + // if they are different reset `option = defaultOption` + var defaultableOptions = ['sorted', 'filtered', 'resized', 'expanded']; + defaultableOptions.forEach(function (x) { + var defaultName = 'default' + (x.charAt(0).toUpperCase() + x.slice(1)); + if (JSON.stringify(oldState[defaultName]) !== JSON.stringify(newState[defaultName])) { + newState[x] = newState[defaultName]; + } + }); + + // If they change these table options, we need to reset defaults + // or else we could get into a state where the user has changed the UI + // and then disabled the ability to change it back. + // e.g. If `filterable` has changed, set `filtered = defaultFiltered` + var resettableOptions = ['sortable', 'filterable', 'resizable']; + resettableOptions.forEach(function (x) { + if (oldState[x] !== newState[x]) { + var baseName = x.replace('able', ''); + var optionName = baseName + 'ed'; + var defaultName = 'default' + (optionName.charAt(0).toUpperCase() + optionName.slice(1)); + newState[optionName] = newState[defaultName]; + } + }); + + // Props that trigger a data update + if (oldState.data !== newState.data || oldState.columns !== newState.columns || oldState.pivotBy !== newState.pivotBy || oldState.sorted !== newState.sorted || oldState.filtered !== newState.filtered) { + this.setStateWithData(this.getDataModel(newState, oldState.data !== newState.data)); + } + } + }, { + key: 'setStateWithData', + value: function setStateWithData(newState, cb) { + var _this2 = this; + + var oldState = this.getResolvedState(); + var newResolvedState = this.getResolvedState({}, newState); + var freezeWhenExpanded = newResolvedState.freezeWhenExpanded; + + // Default to unfrozen state + + newResolvedState.frozen = false; + + // If freezeWhenExpanded is set, check for frozen conditions + if (freezeWhenExpanded) { + // if any rows are expanded, freeze the existing data and sorting + var keys = Object.keys(newResolvedState.expanded); + for (var i = 0; i < keys.length; i += 1) { + if (newResolvedState.expanded[keys[i]]) { + newResolvedState.frozen = true; + break; + } + } + } + + // If the data isn't frozen and either the data or + // sorting model has changed, update the data + if (oldState.frozen && !newResolvedState.frozen || oldState.sorted !== newResolvedState.sorted || oldState.filtered !== newResolvedState.filtered || oldState.showFilters !== newResolvedState.showFilters || !newResolvedState.frozen && oldState.resolvedData !== newResolvedState.resolvedData) { + // Handle collapseOnsortedChange & collapseOnDataChange + if (oldState.sorted !== newResolvedState.sorted && this.props.collapseOnSortingChange || oldState.filtered !== newResolvedState.filtered || oldState.showFilters !== newResolvedState.showFilters || oldState.sortedData && !newResolvedState.frozen && oldState.resolvedData !== newResolvedState.resolvedData && this.props.collapseOnDataChange) { + newResolvedState.expanded = {}; + } + + Object.assign(newResolvedState, this.getSortedData(newResolvedState)); + } + + // Set page to 0 if filters change + if (oldState.filtered !== newResolvedState.filtered) { + newResolvedState.page = 0; + } + + // Calculate pageSize all the time + if (newResolvedState.sortedData) { + newResolvedState.pages = newResolvedState.manual ? newResolvedState.pages : Math.ceil(newResolvedState.sortedData.length / newResolvedState.pageSize); + newResolvedState.page = newResolvedState.manual ? newResolvedState.page : Math.max(newResolvedState.page >= newResolvedState.pages ? newResolvedState.pages - 1 : newResolvedState.page, 0); + } + + return this.setState(newResolvedState, function () { + if (cb) { + cb(); + } + if (oldState.page !== newResolvedState.page || oldState.pageSize !== newResolvedState.pageSize || oldState.sorted !== newResolvedState.sorted || oldState.filtered !== newResolvedState.filtered) { + _this2.fireFetchData(); + } + }); + } + }]); + + return _class; + }(Base); +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/lifecycle.js"],"names":["setStateWithData","getDataModel","getResolvedState","fireFetchData","nextProps","nextState","oldState","newState","defaultableOptions","forEach","defaultName","x","charAt","toUpperCase","slice","JSON","stringify","resettableOptions","baseName","replace","optionName","data","columns","pivotBy","sorted","filtered","cb","newResolvedState","freezeWhenExpanded","frozen","keys","Object","expanded","i","length","showFilters","resolvedData","props","collapseOnSortingChange","sortedData","collapseOnDataChange","assign","getSortedData","page","pages","manual","Math","ceil","pageSize","max","setState","Base"],"mappings":"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","file":"lifecycle.js","sourcesContent":["export default Base =>\n  class extends Base {\n    componentWillMount () {\n      this.setStateWithData(this.getDataModel(this.getResolvedState(), true))\n    }\n\n    componentDidMount () {\n      this.fireFetchData()\n    }\n\n    componentWillReceiveProps (nextProps, nextState) {\n      const oldState = this.getResolvedState()\n      const newState = this.getResolvedState(nextProps, nextState)\n\n      // Do a deep compare of new and old `defaultOption` and\n      // if they are different reset `option = defaultOption`\n      const defaultableOptions = ['sorted', 'filtered', 'resized', 'expanded']\n      defaultableOptions.forEach(x => {\n        const defaultName = `default${x.charAt(0).toUpperCase() + x.slice(1)}`\n        if (JSON.stringify(oldState[defaultName]) !== JSON.stringify(newState[defaultName])) {\n          newState[x] = newState[defaultName]\n        }\n      })\n\n      // If they change these table options, we need to reset defaults\n      // or else we could get into a state where the user has changed the UI\n      // and then disabled the ability to change it back.\n      // e.g. If `filterable` has changed, set `filtered = defaultFiltered`\n      const resettableOptions = ['sortable', 'filterable', 'resizable']\n      resettableOptions.forEach(x => {\n        if (oldState[x] !== newState[x]) {\n          const baseName = x.replace('able', '')\n          const optionName = `${baseName}ed`\n          const defaultName = `default${optionName.charAt(0).toUpperCase() + optionName.slice(1)}`\n          newState[optionName] = newState[defaultName]\n        }\n      })\n\n      // Props that trigger a data update\n      if (\n        oldState.data !== newState.data ||\n        oldState.columns !== newState.columns ||\n        oldState.pivotBy !== newState.pivotBy ||\n        oldState.sorted !== newState.sorted ||\n        oldState.filtered !== newState.filtered\n      ) {\n        this.setStateWithData(this.getDataModel(newState, oldState.data !== newState.data))\n      }\n    }\n\n    setStateWithData (newState, cb) {\n      const oldState = this.getResolvedState()\n      const newResolvedState = this.getResolvedState({}, newState)\n      const { freezeWhenExpanded } = newResolvedState\n\n      // Default to unfrozen state\n      newResolvedState.frozen = false\n\n      // If freezeWhenExpanded is set, check for frozen conditions\n      if (freezeWhenExpanded) {\n        // if any rows are expanded, freeze the existing data and sorting\n        const keys = Object.keys(newResolvedState.expanded)\n        for (let i = 0; i < keys.length; i += 1) {\n          if (newResolvedState.expanded[keys[i]]) {\n            newResolvedState.frozen = true\n            break\n          }\n        }\n      }\n\n      // If the data isn't frozen and either the data or\n      // sorting model has changed, update the data\n      if (\n        (oldState.frozen && !newResolvedState.frozen) ||\n        oldState.sorted !== newResolvedState.sorted ||\n        oldState.filtered !== newResolvedState.filtered ||\n        oldState.showFilters !== newResolvedState.showFilters ||\n        (!newResolvedState.frozen && oldState.resolvedData !== newResolvedState.resolvedData)\n      ) {\n        // Handle collapseOnsortedChange & collapseOnDataChange\n        if (\n          (oldState.sorted !== newResolvedState.sorted && this.props.collapseOnSortingChange) ||\n          oldState.filtered !== newResolvedState.filtered ||\n          oldState.showFilters !== newResolvedState.showFilters ||\n          (oldState.sortedData &&\n            !newResolvedState.frozen &&\n            oldState.resolvedData !== newResolvedState.resolvedData &&\n            this.props.collapseOnDataChange)\n        ) {\n          newResolvedState.expanded = {}\n        }\n\n        Object.assign(newResolvedState, this.getSortedData(newResolvedState))\n      }\n\n      // Set page to 0 if filters change\n      if (oldState.filtered !== newResolvedState.filtered) {\n        newResolvedState.page = 0\n      }\n\n      // Calculate pageSize all the time\n      if (newResolvedState.sortedData) {\n        newResolvedState.pages = newResolvedState.manual\n          ? newResolvedState.pages\n          : Math.ceil(newResolvedState.sortedData.length / newResolvedState.pageSize)\n        newResolvedState.page = newResolvedState.manual ? newResolvedState.page : Math.max(\n          newResolvedState.page >= newResolvedState.pages\n            ? newResolvedState.pages - 1\n            : newResolvedState.page,\n          0\n        )\n      }\n\n      return this.setState(newResolvedState, () => {\n        if (cb) {\n          cb()\n        }\n        if (\n          oldState.page !== newResolvedState.page ||\n          oldState.pageSize !== newResolvedState.pageSize ||\n          oldState.sorted !== newResolvedState.sorted ||\n          oldState.filtered !== newResolvedState.filtered\n        ) {\n          this.fireFetchData()\n        }\n      })\n    }\n  }\n"]} \ No newline at end of file diff --git a/es/methods.js b/es/methods.js new file mode 100644 index 0000000000..f5329ffbb8 --- /dev/null +++ b/es/methods.js @@ -0,0 +1,739 @@ +var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); + +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; }; }(); + +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 _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; } + +import React from 'react'; +import _ from './utils'; + +export default (function (Base) { + return function (_Base) { + _inherits(_class, _Base); + + function _class() { + _classCallCheck(this, _class); + + return _possibleConstructorReturn(this, (_class.__proto__ || Object.getPrototypeOf(_class)).apply(this, arguments)); + } + + _createClass(_class, [{ + key: 'getResolvedState', + value: function getResolvedState(props, state) { + var resolvedState = _extends({}, _.compactObject(this.state), _.compactObject(this.props), _.compactObject(state), _.compactObject(props)); + return resolvedState; + } + }, { + key: 'getDataModel', + value: function getDataModel(newState, dataChanged) { + var _this2 = this; + + var columns = newState.columns, + _newState$pivotBy = newState.pivotBy, + pivotBy = _newState$pivotBy === undefined ? [] : _newState$pivotBy, + data = newState.data, + resolveData = newState.resolveData, + pivotIDKey = newState.pivotIDKey, + pivotValKey = newState.pivotValKey, + subRowsKey = newState.subRowsKey, + aggregatedKey = newState.aggregatedKey, + nestingLevelKey = newState.nestingLevelKey, + originalKey = newState.originalKey, + indexKey = newState.indexKey, + groupedByPivotKey = newState.groupedByPivotKey, + SubComponent = newState.SubComponent; + + // Determine Header Groups + + var hasHeaderGroups = false; + columns.forEach(function (column) { + if (column.columns) { + hasHeaderGroups = true; + } + }); + + var columnsWithExpander = [].concat(_toConsumableArray(columns)); + + var expanderColumn = columns.find(function (col) { + return col.expander || col.columns && col.columns.some(function (col2) { + return col2.expander; + }); + }); + // The actual expander might be in the columns field of a group column + if (expanderColumn && !expanderColumn.expander) { + expanderColumn = expanderColumn.columns.find(function (col) { + return col.expander; + }); + } + + // If we have SubComponent's we need to make sure we have an expander column + if (SubComponent && !expanderColumn) { + expanderColumn = { expander: true }; + columnsWithExpander = [expanderColumn].concat(_toConsumableArray(columnsWithExpander)); + } + + var makeDecoratedColumn = function makeDecoratedColumn(column, parentColumn) { + var dcol = void 0; + if (column.expander) { + dcol = _extends({}, _this2.props.column, _this2.props.expanderDefaults, column); + } else { + dcol = _extends({}, _this2.props.column, column); + } + + // Ensure minWidth is not greater than maxWidth if set + if (dcol.maxWidth < dcol.minWidth) { + dcol.minWidth = dcol.maxWidth; + } + + if (parentColumn) { + dcol.parentColumn = parentColumn; + } + + // First check for string accessor + if (typeof dcol.accessor === 'string') { + dcol.id = dcol.id || dcol.accessor; + var accessorString = dcol.accessor; + dcol.accessor = function (row) { + return _.get(row, accessorString); + }; + return dcol; + } + + // Fall back to functional accessor (but require an ID) + if (dcol.accessor && !dcol.id) { + console.warn(dcol); + throw new Error('A column id is required if using a non-string accessor for column above.'); + } + + // Fall back to an undefined accessor + if (!dcol.accessor) { + dcol.accessor = function () { + return undefined; + }; + } + + return dcol; + }; + + var allDecoratedColumns = []; + + // Decorate the columns + var decorateAndAddToAll = function decorateAndAddToAll(column, parentColumn) { + var decoratedColumn = makeDecoratedColumn(column, parentColumn); + allDecoratedColumns.push(decoratedColumn); + return decoratedColumn; + }; + + var decoratedColumns = columnsWithExpander.map(function (column) { + if (column.columns) { + return _extends({}, column, { + columns: column.columns.map(function (d) { + return decorateAndAddToAll(d, column); + }) + }); + } + return decorateAndAddToAll(column); + }); + + // Build the visible columns, headers and flat column list + var visibleColumns = decoratedColumns.slice(); + var allVisibleColumns = []; + + visibleColumns = visibleColumns.map(function (column) { + if (column.columns) { + var visibleSubColumns = column.columns.filter(function (d) { + return pivotBy.indexOf(d.id) > -1 ? false : _.getFirstDefined(d.show, true); + }); + return _extends({}, column, { + columns: visibleSubColumns + }); + } + return column; + }); + + visibleColumns = visibleColumns.filter(function (column) { + return column.columns ? column.columns.length : pivotBy.indexOf(column.id) > -1 ? false : _.getFirstDefined(column.show, true); + }); + + // Find any custom pivot location + var pivotIndex = visibleColumns.findIndex(function (col) { + return col.pivot; + }); + + // Handle Pivot Columns + if (pivotBy.length) { + // Retrieve the pivot columns in the correct pivot order + var pivotColumns = []; + pivotBy.forEach(function (pivotID) { + var found = allDecoratedColumns.find(function (d) { + return d.id === pivotID; + }); + if (found) { + pivotColumns.push(found); + } + }); + + var PivotParentColumn = pivotColumns.reduce(function (prev, current) { + return prev && prev === current.parentColumn && current.parentColumn; + }, pivotColumns[0].parentColumn); + + var PivotGroupHeader = hasHeaderGroups && PivotParentColumn.Header; + PivotGroupHeader = PivotGroupHeader || function () { + return React.createElement( + 'strong', + null, + 'Pivoted' + ); + }; + + var pivotColumnGroup = { + Header: PivotGroupHeader, + columns: pivotColumns.map(function (col) { + return _extends({}, _this2.props.pivotDefaults, col, { + pivoted: true + }); + }) + + // Place the pivotColumns back into the visibleColumns + };if (pivotIndex >= 0) { + pivotColumnGroup = _extends({}, visibleColumns[pivotIndex], pivotColumnGroup); + visibleColumns.splice(pivotIndex, 1, pivotColumnGroup); + } else { + visibleColumns.unshift(pivotColumnGroup); + } + } + + // Build Header Groups + var headerGroups = []; + var currentSpan = []; + + // A convenience function to add a header and reset the currentSpan + var addHeader = function addHeader(columns, column) { + headerGroups.push(_extends({}, _this2.props.column, column, { + columns: columns + })); + currentSpan = []; + }; + + // Build flast list of allVisibleColumns and HeaderGroups + visibleColumns.forEach(function (column) { + if (column.columns) { + allVisibleColumns = allVisibleColumns.concat(column.columns); + if (currentSpan.length > 0) { + addHeader(currentSpan); + } + addHeader(column.columns, column); + return; + } + allVisibleColumns.push(column); + currentSpan.push(column); + }); + if (hasHeaderGroups && currentSpan.length > 0) { + addHeader(currentSpan); + } + + // Access the data + var accessRow = function accessRow(d, i) { + var _row; + + var level = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0; + + var row = (_row = {}, _defineProperty(_row, originalKey, d), _defineProperty(_row, indexKey, i), _defineProperty(_row, subRowsKey, d[subRowsKey]), _defineProperty(_row, nestingLevelKey, level), _row); + allDecoratedColumns.forEach(function (column) { + if (column.expander) return; + row[column.id] = column.accessor(d); + }); + if (row[subRowsKey]) { + row[subRowsKey] = row[subRowsKey].map(function (d, i) { + return accessRow(d, i, level + 1); + }); + } + return row; + }; + + // // If the data hasn't changed, just use the cached data + var resolvedData = this.resolvedData; + // If the data has changed, run the data resolver and cache the result + if (!this.resolvedData || dataChanged) { + resolvedData = resolveData(data); + this.resolvedData = resolvedData; + } + // Use the resolved data + resolvedData = resolvedData.map(function (d, i) { + return accessRow(d, i); + }); + + // TODO: Make it possible to fabricate nested rows without pivoting + var aggregatingColumns = allVisibleColumns.filter(function (d) { + return !d.expander && d.aggregate; + }); + + // If pivoting, recursively group the data + var aggregate = function aggregate(rows) { + var aggregationValues = {}; + aggregatingColumns.forEach(function (column) { + var values = rows.map(function (d) { + return d[column.id]; + }); + aggregationValues[column.id] = column.aggregate(values, rows); + }); + return aggregationValues; + }; + if (pivotBy.length) { + var groupRecursively = function groupRecursively(rows, keys) { + var i = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0; + + // This is the last level, just return the rows + if (i === keys.length) { + return rows; + } + // Group the rows together for this level + var groupedRows = Object.entries(_.groupBy(rows, keys[i])).map(function (_ref) { + var _ref3; + + var _ref2 = _slicedToArray(_ref, 2), + key = _ref2[0], + value = _ref2[1]; + + return _ref3 = {}, _defineProperty(_ref3, pivotIDKey, keys[i]), _defineProperty(_ref3, pivotValKey, key), _defineProperty(_ref3, keys[i], key), _defineProperty(_ref3, subRowsKey, value), _defineProperty(_ref3, nestingLevelKey, i), _defineProperty(_ref3, groupedByPivotKey, true), _ref3; + }); + // Recurse into the subRows + groupedRows = groupedRows.map(function (rowGroup) { + var _extends2; + + var subRows = groupRecursively(rowGroup[subRowsKey], keys, i + 1); + return _extends({}, rowGroup, (_extends2 = {}, _defineProperty(_extends2, subRowsKey, subRows), _defineProperty(_extends2, aggregatedKey, true), _extends2), aggregate(subRows)); + }); + return groupedRows; + }; + resolvedData = groupRecursively(resolvedData, pivotBy); + } + + return _extends({}, newState, { + resolvedData: resolvedData, + allVisibleColumns: allVisibleColumns, + headerGroups: headerGroups, + allDecoratedColumns: allDecoratedColumns, + hasHeaderGroups: hasHeaderGroups + }); + } + }, { + key: 'getSortedData', + value: function getSortedData(resolvedState) { + var manual = resolvedState.manual, + sorted = resolvedState.sorted, + filtered = resolvedState.filtered, + defaultFilterMethod = resolvedState.defaultFilterMethod, + resolvedData = resolvedState.resolvedData, + allVisibleColumns = resolvedState.allVisibleColumns, + allDecoratedColumns = resolvedState.allDecoratedColumns; + + + var sortMethodsByColumnID = {}; + + allDecoratedColumns.filter(function (col) { + return col.sortMethod; + }).forEach(function (col) { + sortMethodsByColumnID[col.id] = col.sortMethod; + }); + + // Resolve the data from either manual data or sorted data + return { + sortedData: manual ? resolvedData : this.sortData(this.filterData(resolvedData, filtered, defaultFilterMethod, allVisibleColumns), sorted, sortMethodsByColumnID) + }; + } + }, { + key: 'fireFetchData', + value: function fireFetchData() { + this.props.onFetchData(this.getResolvedState(), this); + } + }, { + key: 'getPropOrState', + value: function getPropOrState(key) { + return _.getFirstDefined(this.props[key], this.state[key]); + } + }, { + key: 'getStateOrProp', + value: function getStateOrProp(key) { + return _.getFirstDefined(this.state[key], this.props[key]); + } + }, { + key: 'filterData', + value: function filterData(data, filtered, defaultFilterMethod, allVisibleColumns) { + var _this3 = this; + + var filteredData = data; + + if (filtered.length) { + filteredData = filtered.reduce(function (filteredSoFar, nextFilter) { + var column = allVisibleColumns.find(function (x) { + return x.id === nextFilter.id; + }); + + // Don't filter hidden columns or columns that have had their filters disabled + if (!column || column.filterable === false) { + return filteredSoFar; + } + + var filterMethod = column.filterMethod || defaultFilterMethod; + + // If 'filterAll' is set to true, pass the entire dataset to the filter method + if (column.filterAll) { + return filterMethod(nextFilter, filteredSoFar, column); + } + return filteredSoFar.filter(function (row) { + return filterMethod(nextFilter, row, column); + }); + }, filteredData); + + // Apply the filter to the subrows if we are pivoting, and then + // filter any rows without subcolumns because it would be strange to show + filteredData = filteredData.map(function (row) { + if (!row[_this3.props.subRowsKey]) { + return row; + } + return _extends({}, row, _defineProperty({}, _this3.props.subRowsKey, _this3.filterData(row[_this3.props.subRowsKey], filtered, defaultFilterMethod, allVisibleColumns))); + }).filter(function (row) { + if (!row[_this3.props.subRowsKey]) { + return true; + } + return row[_this3.props.subRowsKey].length > 0; + }); + } + + return filteredData; + } + }, { + key: 'sortData', + value: function sortData(data, sorted) { + var _this4 = this; + + var sortMethodsByColumnID = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + if (!sorted.length) { + return data; + } + + var sortedData = (this.props.orderByMethod || _.orderBy)(data, sorted.map(function (sort) { + // Support custom sorting methods for each column + if (sortMethodsByColumnID[sort.id]) { + return function (a, b) { + return sortMethodsByColumnID[sort.id](a[sort.id], b[sort.id], sort.desc); + }; + } + return function (a, b) { + return _this4.props.defaultSortMethod(a[sort.id], b[sort.id], sort.desc); + }; + }), sorted.map(function (d) { + return !d.desc; + }), this.props.indexKey); + + sortedData.forEach(function (row) { + if (!row[_this4.props.subRowsKey]) { + return; + } + row[_this4.props.subRowsKey] = _this4.sortData(row[_this4.props.subRowsKey], sorted, sortMethodsByColumnID); + }); + + return sortedData; + } + }, { + key: 'getMinRows', + value: function getMinRows() { + return _.getFirstDefined(this.props.minRows, this.getStateOrProp('pageSize')); + } + + // User actions + + }, { + key: 'onPageChange', + value: function onPageChange(page) { + var _props = this.props, + onPageChange = _props.onPageChange, + collapseOnPageChange = _props.collapseOnPageChange; + + + var newState = { page: page }; + if (collapseOnPageChange) { + newState.expanded = {}; + } + this.setStateWithData(newState, function () { + return onPageChange && onPageChange(page); + }); + } + }, { + key: 'onPageSizeChange', + value: function onPageSizeChange(newPageSize) { + var onPageSizeChange = this.props.onPageSizeChange; + + var _getResolvedState = this.getResolvedState(), + pageSize = _getResolvedState.pageSize, + page = _getResolvedState.page; + + // Normalize the page to display + + + var currentRow = pageSize * page; + var newPage = Math.floor(currentRow / newPageSize); + + this.setStateWithData({ + pageSize: newPageSize, + page: newPage + }, function () { + return onPageSizeChange && onPageSizeChange(newPageSize, newPage); + }); + } + }, { + key: 'sortColumn', + value: function sortColumn(column, additive) { + var _getResolvedState2 = this.getResolvedState(), + sorted = _getResolvedState2.sorted, + skipNextSort = _getResolvedState2.skipNextSort, + defaultSortDesc = _getResolvedState2.defaultSortDesc; + + var firstSortDirection = Object.prototype.hasOwnProperty.call(column, 'defaultSortDesc') ? column.defaultSortDesc : defaultSortDesc; + var secondSortDirection = !firstSortDirection; + + // we can't stop event propagation from the column resize move handlers + // attached to the document because of react's synthetic events + // so we have to prevent the sort function from actually sorting + // if we click on the column resize element within a header. + if (skipNextSort) { + this.setStateWithData({ + skipNextSort: false + }); + return; + } + + var onSortedChange = this.props.onSortedChange; + + + var newSorted = _.clone(sorted || []).map(function (d) { + d.desc = _.isSortingDesc(d); + return d; + }); + if (!_.isArray(column)) { + // Single-Sort + var existingIndex = newSorted.findIndex(function (d) { + return d.id === column.id; + }); + if (existingIndex > -1) { + var existing = newSorted[existingIndex]; + if (existing.desc === secondSortDirection) { + if (additive) { + newSorted.splice(existingIndex, 1); + } else { + existing.desc = firstSortDirection; + newSorted = [existing]; + } + } else { + existing.desc = secondSortDirection; + if (!additive) { + newSorted = [existing]; + } + } + } else if (additive) { + newSorted.push({ + id: column.id, + desc: firstSortDirection + }); + } else { + newSorted = [{ + id: column.id, + desc: firstSortDirection + }]; + } + } else { + // Multi-Sort + var _existingIndex = newSorted.findIndex(function (d) { + return d.id === column[0].id; + }); + // Existing Sorted Column + if (_existingIndex > -1) { + var _existing = newSorted[_existingIndex]; + if (_existing.desc === secondSortDirection) { + if (additive) { + newSorted.splice(_existingIndex, column.length); + } else { + column.forEach(function (d, i) { + newSorted[_existingIndex + i].desc = firstSortDirection; + }); + } + } else { + column.forEach(function (d, i) { + newSorted[_existingIndex + i].desc = secondSortDirection; + }); + } + if (!additive) { + newSorted = newSorted.slice(_existingIndex, column.length); + } + // New Sort Column + } else if (additive) { + newSorted = newSorted.concat(column.map(function (d) { + return { + id: d.id, + desc: firstSortDirection + }; + })); + } else { + newSorted = column.map(function (d) { + return { + id: d.id, + desc: firstSortDirection + }; + }); + } + } + + this.setStateWithData({ + page: !sorted.length && newSorted.length || !additive ? 0 : this.state.page, + sorted: newSorted + }, function () { + return onSortedChange && onSortedChange(newSorted, column, additive); + }); + } + }, { + key: 'filterColumn', + value: function filterColumn(column, value) { + var _getResolvedState3 = this.getResolvedState(), + filtered = _getResolvedState3.filtered; + + var onFilteredChange = this.props.onFilteredChange; + + // Remove old filter first if it exists + + var newFiltering = (filtered || []).filter(function (x) { + return x.id !== column.id; + }); + + if (value !== '') { + newFiltering.push({ + id: column.id, + value: value + }); + } + + this.setStateWithData({ + filtered: newFiltering + }, function () { + return onFilteredChange && onFilteredChange(newFiltering, column, value); + }); + } + }, { + key: 'resizeColumnStart', + value: function resizeColumnStart(event, column, isTouch) { + var _this5 = this; + + event.stopPropagation(); + var parentWidth = event.target.parentElement.getBoundingClientRect().width; + + var pageX = void 0; + if (isTouch) { + pageX = event.changedTouches[0].pageX; + } else { + pageX = event.pageX; + } + + this.trapEvents = true; + this.setStateWithData({ + currentlyResizing: { + id: column.id, + startX: pageX, + parentWidth: parentWidth + } + }, function () { + if (isTouch) { + document.addEventListener('touchmove', _this5.resizeColumnMoving); + document.addEventListener('touchcancel', _this5.resizeColumnEnd); + document.addEventListener('touchend', _this5.resizeColumnEnd); + } else { + document.addEventListener('mousemove', _this5.resizeColumnMoving); + document.addEventListener('mouseup', _this5.resizeColumnEnd); + document.addEventListener('mouseleave', _this5.resizeColumnEnd); + } + }); + } + }, { + key: 'resizeColumnMoving', + value: function resizeColumnMoving(event) { + event.stopPropagation(); + var onResizedChange = this.props.onResizedChange; + + var _getResolvedState4 = this.getResolvedState(), + resized = _getResolvedState4.resized, + currentlyResizing = _getResolvedState4.currentlyResizing; + + // Delete old value + + + var newResized = resized.filter(function (x) { + return x.id !== currentlyResizing.id; + }); + + var pageX = void 0; + + if (event.type === 'touchmove') { + pageX = event.changedTouches[0].pageX; + } else if (event.type === 'mousemove') { + pageX = event.pageX; + } + + // Set the min size to 10 to account for margin and border or else the + // group headers don't line up correctly + var newWidth = Math.max(currentlyResizing.parentWidth + pageX - currentlyResizing.startX, 11); + + newResized.push({ + id: currentlyResizing.id, + value: newWidth + }); + + this.setStateWithData({ + resized: newResized + }, function () { + return onResizedChange && onResizedChange(newResized, event); + }); + } + }, { + key: 'resizeColumnEnd', + value: function resizeColumnEnd(event) { + event.stopPropagation(); + var isTouch = event.type === 'touchend' || event.type === 'touchcancel'; + + if (isTouch) { + document.removeEventListener('touchmove', this.resizeColumnMoving); + document.removeEventListener('touchcancel', this.resizeColumnEnd); + document.removeEventListener('touchend', this.resizeColumnEnd); + } + + // If its a touch event clear the mouse one's as well because sometimes + // the mouseDown event gets called as well, but the mouseUp event doesn't + document.removeEventListener('mousemove', this.resizeColumnMoving); + document.removeEventListener('mouseup', this.resizeColumnEnd); + document.removeEventListener('mouseleave', this.resizeColumnEnd); + + // The touch events don't propagate up to the sorting's onMouseDown event so + // no need to prevent it from happening or else the first click after a touch + // event resize will not sort the column. + if (!isTouch) { + this.setStateWithData({ + skipNextSort: true, + currentlyResizing: false + }); + } + } + }]); + + return _class; + }(Base); +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/methods.js"],"names":["React","_","props","state","resolvedState","compactObject","newState","dataChanged","columns","pivotBy","data","resolveData","pivotIDKey","pivotValKey","subRowsKey","aggregatedKey","nestingLevelKey","originalKey","indexKey","groupedByPivotKey","SubComponent","hasHeaderGroups","forEach","column","columnsWithExpander","expanderColumn","find","col","expander","some","col2","makeDecoratedColumn","parentColumn","dcol","expanderDefaults","maxWidth","minWidth","accessor","id","accessorString","get","row","console","warn","Error","undefined","allDecoratedColumns","decorateAndAddToAll","decoratedColumn","push","decoratedColumns","map","d","visibleColumns","slice","allVisibleColumns","visibleSubColumns","filter","indexOf","getFirstDefined","show","length","pivotIndex","findIndex","pivot","pivotColumns","found","pivotID","PivotParentColumn","reduce","prev","current","PivotGroupHeader","Header","pivotColumnGroup","pivotDefaults","pivoted","splice","unshift","headerGroups","currentSpan","addHeader","concat","accessRow","i","level","resolvedData","aggregatingColumns","aggregate","aggregationValues","values","rows","groupRecursively","keys","groupedRows","Object","entries","groupBy","key","value","subRows","rowGroup","manual","sorted","filtered","defaultFilterMethod","sortMethodsByColumnID","sortMethod","sortedData","sortData","filterData","onFetchData","getResolvedState","filteredData","filteredSoFar","nextFilter","x","filterable","filterMethod","filterAll","orderByMethod","orderBy","sort","a","b","desc","defaultSortMethod","minRows","getStateOrProp","page","onPageChange","collapseOnPageChange","expanded","setStateWithData","newPageSize","onPageSizeChange","pageSize","currentRow","newPage","Math","floor","additive","skipNextSort","defaultSortDesc","firstSortDirection","prototype","hasOwnProperty","call","secondSortDirection","onSortedChange","newSorted","clone","isSortingDesc","isArray","existingIndex","existing","onFilteredChange","newFiltering","event","isTouch","stopPropagation","parentWidth","target","parentElement","getBoundingClientRect","width","pageX","changedTouches","trapEvents","currentlyResizing","startX","document","addEventListener","resizeColumnMoving","resizeColumnEnd","onResizedChange","resized","newResized","type","newWidth","max","removeEventListener","Base"],"mappings":"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","file":"methods.js","sourcesContent":["import React from 'react'\nimport _ from './utils'\n\nexport default Base =>\n  class extends Base {\n    getResolvedState (props, state) {\n      const resolvedState = {\n        ..._.compactObject(this.state),\n        ..._.compactObject(this.props),\n        ..._.compactObject(state),\n        ..._.compactObject(props),\n      }\n      return resolvedState\n    }\n\n    getDataModel (newState, dataChanged) {\n      const {\n        columns,\n        pivotBy = [],\n        data,\n        resolveData,\n        pivotIDKey,\n        pivotValKey,\n        subRowsKey,\n        aggregatedKey,\n        nestingLevelKey,\n        originalKey,\n        indexKey,\n        groupedByPivotKey,\n        SubComponent,\n      } = newState\n\n      // Determine Header Groups\n      let hasHeaderGroups = false\n      columns.forEach(column => {\n        if (column.columns) {\n          hasHeaderGroups = true\n        }\n      })\n\n      let columnsWithExpander = [...columns]\n\n      let expanderColumn = columns.find(\n        col => col.expander || (col.columns && col.columns.some(col2 => col2.expander))\n      )\n      // The actual expander might be in the columns field of a group column\n      if (expanderColumn && !expanderColumn.expander) {\n        expanderColumn = expanderColumn.columns.find(col => col.expander)\n      }\n\n      // If we have SubComponent's we need to make sure we have an expander column\n      if (SubComponent && !expanderColumn) {\n        expanderColumn = { expander: true }\n        columnsWithExpander = [expanderColumn, ...columnsWithExpander]\n      }\n\n      const makeDecoratedColumn = (column, parentColumn) => {\n        let dcol\n        if (column.expander) {\n          dcol = {\n            ...this.props.column,\n            ...this.props.expanderDefaults,\n            ...column,\n          }\n        } else {\n          dcol = {\n            ...this.props.column,\n            ...column,\n          }\n        }\n\n        // Ensure minWidth is not greater than maxWidth if set\n        if (dcol.maxWidth < dcol.minWidth) {\n          dcol.minWidth = dcol.maxWidth\n        }\n\n        if (parentColumn) {\n          dcol.parentColumn = parentColumn\n        }\n\n        // First check for string accessor\n        if (typeof dcol.accessor === 'string') {\n          dcol.id = dcol.id || dcol.accessor\n          const accessorString = dcol.accessor\n          dcol.accessor = row => _.get(row, accessorString)\n          return dcol\n        }\n\n        // Fall back to functional accessor (but require an ID)\n        if (dcol.accessor && !dcol.id) {\n          console.warn(dcol)\n          throw new Error(\n            'A column id is required if using a non-string accessor for column above.'\n          )\n        }\n\n        // Fall back to an undefined accessor\n        if (!dcol.accessor) {\n          dcol.accessor = () => undefined\n        }\n\n        return dcol\n      }\n\n      const allDecoratedColumns = []\n\n      // Decorate the columns\n      const decorateAndAddToAll = (column, parentColumn) => {\n        const decoratedColumn = makeDecoratedColumn(column, parentColumn)\n        allDecoratedColumns.push(decoratedColumn)\n        return decoratedColumn\n      }\n\n      const decoratedColumns = columnsWithExpander.map(column => {\n        if (column.columns) {\n          return {\n            ...column,\n            columns: column.columns.map(d => decorateAndAddToAll(d, column)),\n          }\n        }\n        return decorateAndAddToAll(column)\n      })\n\n      // Build the visible columns, headers and flat column list\n      let visibleColumns = decoratedColumns.slice()\n      let allVisibleColumns = []\n\n      visibleColumns = visibleColumns.map(column => {\n        if (column.columns) {\n          const visibleSubColumns = column.columns.filter(\n            d => (pivotBy.indexOf(d.id) > -1 ? false : _.getFirstDefined(d.show, true))\n          )\n          return {\n            ...column,\n            columns: visibleSubColumns,\n          }\n        }\n        return column\n      })\n\n      visibleColumns = visibleColumns.filter(\n        column =>\n          column.columns\n            ? column.columns.length\n            : pivotBy.indexOf(column.id) > -1\n              ? false\n              : _.getFirstDefined(column.show, true)\n      )\n\n      // Find any custom pivot location\n      const pivotIndex = visibleColumns.findIndex(col => col.pivot)\n\n      // Handle Pivot Columns\n      if (pivotBy.length) {\n        // Retrieve the pivot columns in the correct pivot order\n        const pivotColumns = []\n        pivotBy.forEach(pivotID => {\n          const found = allDecoratedColumns.find(d => d.id === pivotID)\n          if (found) {\n            pivotColumns.push(found)\n          }\n        })\n\n        const PivotParentColumn = pivotColumns.reduce(\n          (prev, current) => prev && prev === current.parentColumn && current.parentColumn,\n          pivotColumns[0].parentColumn\n        )\n\n        let PivotGroupHeader = hasHeaderGroups && PivotParentColumn.Header\n        PivotGroupHeader = PivotGroupHeader || (() => <strong>Pivoted</strong>)\n\n        let pivotColumnGroup = {\n          Header: PivotGroupHeader,\n          columns: pivotColumns.map(col => ({\n            ...this.props.pivotDefaults,\n            ...col,\n            pivoted: true,\n          })),\n        }\n\n        // Place the pivotColumns back into the visibleColumns\n        if (pivotIndex >= 0) {\n          pivotColumnGroup = {\n            ...visibleColumns[pivotIndex],\n            ...pivotColumnGroup,\n          }\n          visibleColumns.splice(pivotIndex, 1, pivotColumnGroup)\n        } else {\n          visibleColumns.unshift(pivotColumnGroup)\n        }\n      }\n\n      // Build Header Groups\n      const headerGroups = []\n      let currentSpan = []\n\n      // A convenience function to add a header and reset the currentSpan\n      const addHeader = (columns, column) => {\n        headerGroups.push({\n          ...this.props.column,\n          ...column,\n          columns,\n        })\n        currentSpan = []\n      }\n\n      // Build flast list of allVisibleColumns and HeaderGroups\n      visibleColumns.forEach(column => {\n        if (column.columns) {\n          allVisibleColumns = allVisibleColumns.concat(column.columns)\n          if (currentSpan.length > 0) {\n            addHeader(currentSpan)\n          }\n          addHeader(column.columns, column)\n          return\n        }\n        allVisibleColumns.push(column)\n        currentSpan.push(column)\n      })\n      if (hasHeaderGroups && currentSpan.length > 0) {\n        addHeader(currentSpan)\n      }\n\n      // Access the data\n      const accessRow = (d, i, level = 0) => {\n        const row = {\n          [originalKey]: d,\n          [indexKey]: i,\n          [subRowsKey]: d[subRowsKey],\n          [nestingLevelKey]: level,\n        }\n        allDecoratedColumns.forEach(column => {\n          if (column.expander) return\n          row[column.id] = column.accessor(d)\n        })\n        if (row[subRowsKey]) {\n          row[subRowsKey] = row[subRowsKey].map((d, i) => accessRow(d, i, level + 1))\n        }\n        return row\n      }\n\n      // // If the data hasn't changed, just use the cached data\n      let resolvedData = this.resolvedData\n      // If the data has changed, run the data resolver and cache the result\n      if (!this.resolvedData || dataChanged) {\n        resolvedData = resolveData(data)\n        this.resolvedData = resolvedData\n      }\n      // Use the resolved data\n      resolvedData = resolvedData.map((d, i) => accessRow(d, i))\n\n      // TODO: Make it possible to fabricate nested rows without pivoting\n      const aggregatingColumns = allVisibleColumns.filter(d => !d.expander && d.aggregate)\n\n      // If pivoting, recursively group the data\n      const aggregate = rows => {\n        const aggregationValues = {}\n        aggregatingColumns.forEach(column => {\n          const values = rows.map(d => d[column.id])\n          aggregationValues[column.id] = column.aggregate(values, rows)\n        })\n        return aggregationValues\n      }\n      if (pivotBy.length) {\n        const groupRecursively = (rows, keys, i = 0) => {\n          // This is the last level, just return the rows\n          if (i === keys.length) {\n            return rows\n          }\n          // Group the rows together for this level\n          let groupedRows = Object.entries(_.groupBy(rows, keys[i])).map(([key, value]) => ({\n            [pivotIDKey]: keys[i],\n            [pivotValKey]: key,\n            [keys[i]]: key,\n            [subRowsKey]: value,\n            [nestingLevelKey]: i,\n            [groupedByPivotKey]: true,\n          }))\n          // Recurse into the subRows\n          groupedRows = groupedRows.map(rowGroup => {\n            const subRows = groupRecursively(rowGroup[subRowsKey], keys, i + 1)\n            return {\n              ...rowGroup,\n              [subRowsKey]: subRows,\n              [aggregatedKey]: true,\n              ...aggregate(subRows),\n            }\n          })\n          return groupedRows\n        }\n        resolvedData = groupRecursively(resolvedData, pivotBy)\n      }\n\n      return {\n        ...newState,\n        resolvedData,\n        allVisibleColumns,\n        headerGroups,\n        allDecoratedColumns,\n        hasHeaderGroups,\n      }\n    }\n\n    getSortedData (resolvedState) {\n      const {\n        manual,\n        sorted,\n        filtered,\n        defaultFilterMethod,\n        resolvedData,\n        allVisibleColumns,\n        allDecoratedColumns,\n      } = resolvedState\n\n      const sortMethodsByColumnID = {}\n\n      allDecoratedColumns.filter(col => col.sortMethod).forEach(col => {\n        sortMethodsByColumnID[col.id] = col.sortMethod\n      })\n\n      // Resolve the data from either manual data or sorted data\n      return {\n        sortedData: manual\n          ? resolvedData\n          : this.sortData(\n            this.filterData(resolvedData, filtered, defaultFilterMethod, allVisibleColumns),\n            sorted,\n            sortMethodsByColumnID\n          ),\n      }\n    }\n\n    fireFetchData () {\n      this.props.onFetchData(this.getResolvedState(), this)\n    }\n\n    getPropOrState (key) {\n      return _.getFirstDefined(this.props[key], this.state[key])\n    }\n\n    getStateOrProp (key) {\n      return _.getFirstDefined(this.state[key], this.props[key])\n    }\n\n    filterData (data, filtered, defaultFilterMethod, allVisibleColumns) {\n      let filteredData = data\n\n      if (filtered.length) {\n        filteredData = filtered.reduce((filteredSoFar, nextFilter) => {\n          const column = allVisibleColumns.find(x => x.id === nextFilter.id)\n\n          // Don't filter hidden columns or columns that have had their filters disabled\n          if (!column || column.filterable === false) {\n            return filteredSoFar\n          }\n\n          const filterMethod = column.filterMethod || defaultFilterMethod\n\n          // If 'filterAll' is set to true, pass the entire dataset to the filter method\n          if (column.filterAll) {\n            return filterMethod(nextFilter, filteredSoFar, column)\n          }\n          return filteredSoFar.filter(row => filterMethod(nextFilter, row, column))\n        }, filteredData)\n\n        // Apply the filter to the subrows if we are pivoting, and then\n        // filter any rows without subcolumns because it would be strange to show\n        filteredData = filteredData\n          .map(row => {\n            if (!row[this.props.subRowsKey]) {\n              return row\n            }\n            return {\n              ...row,\n              [this.props.subRowsKey]: this.filterData(\n                row[this.props.subRowsKey],\n                filtered,\n                defaultFilterMethod,\n                allVisibleColumns\n              ),\n            }\n          })\n          .filter(row => {\n            if (!row[this.props.subRowsKey]) {\n              return true\n            }\n            return row[this.props.subRowsKey].length > 0\n          })\n      }\n\n      return filteredData\n    }\n\n    sortData (data, sorted, sortMethodsByColumnID = {}) {\n      if (!sorted.length) {\n        return data\n      }\n\n      const sortedData = (this.props.orderByMethod || _.orderBy)(\n        data,\n        sorted.map(sort => {\n          // Support custom sorting methods for each column\n          if (sortMethodsByColumnID[sort.id]) {\n            return (a, b) => sortMethodsByColumnID[sort.id](a[sort.id], b[sort.id], sort.desc)\n          }\n          return (a, b) => this.props.defaultSortMethod(a[sort.id], b[sort.id], sort.desc)\n        }),\n        sorted.map(d => !d.desc),\n        this.props.indexKey\n      )\n\n      sortedData.forEach(row => {\n        if (!row[this.props.subRowsKey]) {\n          return\n        }\n        row[this.props.subRowsKey] = this.sortData(\n          row[this.props.subRowsKey],\n          sorted,\n          sortMethodsByColumnID\n        )\n      })\n\n      return sortedData\n    }\n\n    getMinRows () {\n      return _.getFirstDefined(this.props.minRows, this.getStateOrProp('pageSize'))\n    }\n\n    // User actions\n    onPageChange (page) {\n      const { onPageChange, collapseOnPageChange } = this.props\n\n      const newState = { page }\n      if (collapseOnPageChange) {\n        newState.expanded = {}\n      }\n      this.setStateWithData(newState, () => onPageChange && onPageChange(page))\n    }\n\n    onPageSizeChange (newPageSize) {\n      const { onPageSizeChange } = this.props\n      const { pageSize, page } = this.getResolvedState()\n\n      // Normalize the page to display\n      const currentRow = pageSize * page\n      const newPage = Math.floor(currentRow / newPageSize)\n\n      this.setStateWithData(\n        {\n          pageSize: newPageSize,\n          page: newPage,\n        },\n        () => onPageSizeChange && onPageSizeChange(newPageSize, newPage)\n      )\n    }\n\n    sortColumn (column, additive) {\n      const { sorted, skipNextSort, defaultSortDesc } = this.getResolvedState()\n\n      const firstSortDirection = Object.prototype.hasOwnProperty.call(column, 'defaultSortDesc')\n        ? column.defaultSortDesc\n        : defaultSortDesc\n      const secondSortDirection = !firstSortDirection\n\n      // we can't stop event propagation from the column resize move handlers\n      // attached to the document because of react's synthetic events\n      // so we have to prevent the sort function from actually sorting\n      // if we click on the column resize element within a header.\n      if (skipNextSort) {\n        this.setStateWithData({\n          skipNextSort: false,\n        })\n        return\n      }\n\n      const { onSortedChange } = this.props\n\n      let newSorted = _.clone(sorted || []).map(d => {\n        d.desc = _.isSortingDesc(d)\n        return d\n      })\n      if (!_.isArray(column)) {\n        // Single-Sort\n        const existingIndex = newSorted.findIndex(d => d.id === column.id)\n        if (existingIndex > -1) {\n          const existing = newSorted[existingIndex]\n          if (existing.desc === secondSortDirection) {\n            if (additive) {\n              newSorted.splice(existingIndex, 1)\n            } else {\n              existing.desc = firstSortDirection\n              newSorted = [existing]\n            }\n          } else {\n            existing.desc = secondSortDirection\n            if (!additive) {\n              newSorted = [existing]\n            }\n          }\n        } else if (additive) {\n          newSorted.push({\n            id: column.id,\n            desc: firstSortDirection,\n          })\n        } else {\n          newSorted = [\n            {\n              id: column.id,\n              desc: firstSortDirection,\n            },\n          ]\n        }\n      } else {\n        // Multi-Sort\n        const existingIndex = newSorted.findIndex(d => d.id === column[0].id)\n        // Existing Sorted Column\n        if (existingIndex > -1) {\n          const existing = newSorted[existingIndex]\n          if (existing.desc === secondSortDirection) {\n            if (additive) {\n              newSorted.splice(existingIndex, column.length)\n            } else {\n              column.forEach((d, i) => {\n                newSorted[existingIndex + i].desc = firstSortDirection\n              })\n            }\n          } else {\n            column.forEach((d, i) => {\n              newSorted[existingIndex + i].desc = secondSortDirection\n            })\n          }\n          if (!additive) {\n            newSorted = newSorted.slice(existingIndex, column.length)\n          }\n          // New Sort Column\n        } else if (additive) {\n          newSorted = newSorted.concat(\n            column.map(d => ({\n              id: d.id,\n              desc: firstSortDirection,\n            }))\n          )\n        } else {\n          newSorted = column.map(d => ({\n            id: d.id,\n            desc: firstSortDirection,\n          }))\n        }\n      }\n\n      this.setStateWithData(\n        {\n          page: (!sorted.length && newSorted.length) || !additive ? 0 : this.state.page,\n          sorted: newSorted,\n        },\n        () => onSortedChange && onSortedChange(newSorted, column, additive)\n      )\n    }\n\n    filterColumn (column, value) {\n      const { filtered } = this.getResolvedState()\n      const { onFilteredChange } = this.props\n\n      // Remove old filter first if it exists\n      const newFiltering = (filtered || []).filter(x => x.id !== column.id)\n\n      if (value !== '') {\n        newFiltering.push({\n          id: column.id,\n          value,\n        })\n      }\n\n      this.setStateWithData(\n        {\n          filtered: newFiltering,\n        },\n        () => onFilteredChange && onFilteredChange(newFiltering, column, value)\n      )\n    }\n\n    resizeColumnStart (event, column, isTouch) {\n      event.stopPropagation()\n      const parentWidth = event.target.parentElement.getBoundingClientRect().width\n\n      let pageX\n      if (isTouch) {\n        pageX = event.changedTouches[0].pageX\n      } else {\n        pageX = event.pageX\n      }\n\n      this.trapEvents = true\n      this.setStateWithData(\n        {\n          currentlyResizing: {\n            id: column.id,\n            startX: pageX,\n            parentWidth,\n          },\n        },\n        () => {\n          if (isTouch) {\n            document.addEventListener('touchmove', this.resizeColumnMoving)\n            document.addEventListener('touchcancel', this.resizeColumnEnd)\n            document.addEventListener('touchend', this.resizeColumnEnd)\n          } else {\n            document.addEventListener('mousemove', this.resizeColumnMoving)\n            document.addEventListener('mouseup', this.resizeColumnEnd)\n            document.addEventListener('mouseleave', this.resizeColumnEnd)\n          }\n        }\n      )\n    }\n\n    resizeColumnMoving (event) {\n      event.stopPropagation()\n      const { onResizedChange } = this.props\n      const { resized, currentlyResizing } = this.getResolvedState()\n\n      // Delete old value\n      const newResized = resized.filter(x => x.id !== currentlyResizing.id)\n\n      let pageX\n\n      if (event.type === 'touchmove') {\n        pageX = event.changedTouches[0].pageX\n      } else if (event.type === 'mousemove') {\n        pageX = event.pageX\n      }\n\n      // Set the min size to 10 to account for margin and border or else the\n      // group headers don't line up correctly\n      const newWidth = Math.max(\n        currentlyResizing.parentWidth + pageX - currentlyResizing.startX,\n        11\n      )\n\n      newResized.push({\n        id: currentlyResizing.id,\n        value: newWidth,\n      })\n\n      this.setStateWithData(\n        {\n          resized: newResized,\n        },\n        () => onResizedChange && onResizedChange(newResized, event)\n      )\n    }\n\n    resizeColumnEnd (event) {\n      event.stopPropagation()\n      const isTouch = event.type === 'touchend' || event.type === 'touchcancel'\n\n      if (isTouch) {\n        document.removeEventListener('touchmove', this.resizeColumnMoving)\n        document.removeEventListener('touchcancel', this.resizeColumnEnd)\n        document.removeEventListener('touchend', this.resizeColumnEnd)\n      }\n\n      // If its a touch event clear the mouse one's as well because sometimes\n      // the mouseDown event gets called as well, but the mouseUp event doesn't\n      document.removeEventListener('mousemove', this.resizeColumnMoving)\n      document.removeEventListener('mouseup', this.resizeColumnEnd)\n      document.removeEventListener('mouseleave', this.resizeColumnEnd)\n\n      // The touch events don't propagate up to the sorting's onMouseDown event so\n      // no need to prevent it from happening or else the first click after a touch\n      // event resize will not sort the column.\n      if (!isTouch) {\n        this.setStateWithData({\n          skipNextSort: true,\n          currentlyResizing: false,\n        })\n      }\n    }\n  }\n"]} \ No newline at end of file diff --git a/es/pagination.js b/es/pagination.js new file mode 100644 index 0000000000..3ea1bcee2a --- /dev/null +++ b/es/pagination.js @@ -0,0 +1,200 @@ +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 _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; }; + +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; } + +import React, { Component } from 'react'; +import classnames from 'classnames'; +// +// import _ from './utils' + +var defaultButton = function defaultButton(props) { + return React.createElement( + 'button', + _extends({ type: 'button' }, props, { className: '-btn' }), + props.children + ); +}; + +var ReactTablePagination = function (_Component) { + _inherits(ReactTablePagination, _Component); + + function ReactTablePagination(props) { + _classCallCheck(this, ReactTablePagination); + + var _this = _possibleConstructorReturn(this, (ReactTablePagination.__proto__ || Object.getPrototypeOf(ReactTablePagination)).call(this)); + + _this.getSafePage = _this.getSafePage.bind(_this); + _this.changePage = _this.changePage.bind(_this); + _this.applyPage = _this.applyPage.bind(_this); + + _this.state = { + page: props.page + }; + return _this; + } + + _createClass(ReactTablePagination, [{ + key: 'componentWillReceiveProps', + value: function componentWillReceiveProps(nextProps) { + this.setState({ page: nextProps.page }); + } + }, { + key: 'getSafePage', + value: function getSafePage(page) { + if (Number.isNaN(page)) { + page = this.props.page; + } + return Math.min(Math.max(page, 0), this.props.pages - 1); + } + }, { + key: 'changePage', + value: function changePage(page) { + page = this.getSafePage(page); + this.setState({ page: page }); + if (this.props.page !== page) { + this.props.onPageChange(page); + } + } + }, { + key: 'applyPage', + value: function applyPage(e) { + if (e) { + e.preventDefault(); + } + var page = this.state.page; + this.changePage(page === '' ? this.props.page : page); + } + }, { + key: 'render', + value: function render() { + var _this2 = this; + + var _props = this.props, + pages = _props.pages, + page = _props.page, + showPageSizeOptions = _props.showPageSizeOptions, + pageSizeOptions = _props.pageSizeOptions, + pageSize = _props.pageSize, + showPageJump = _props.showPageJump, + canPrevious = _props.canPrevious, + canNext = _props.canNext, + onPageSizeChange = _props.onPageSizeChange, + className = _props.className, + _props$PreviousCompon = _props.PreviousComponent, + PreviousComponent = _props$PreviousCompon === undefined ? defaultButton : _props$PreviousCompon, + _props$NextComponent = _props.NextComponent, + NextComponent = _props$NextComponent === undefined ? defaultButton : _props$NextComponent; + + + return React.createElement( + 'div', + { className: classnames(className, '-pagination'), style: this.props.style }, + React.createElement( + 'div', + { className: '-previous' }, + React.createElement( + PreviousComponent, + { + onClick: function onClick() { + if (!canPrevious) return; + _this2.changePage(page - 1); + }, + disabled: !canPrevious + }, + this.props.previousText + ) + ), + React.createElement( + 'div', + { className: '-center' }, + React.createElement( + 'span', + { className: '-pageInfo' }, + this.props.pageText, + ' ', + showPageJump ? React.createElement( + 'div', + { className: '-pageJump' }, + React.createElement('input', { + type: this.state.page === '' ? 'text' : 'number', + onChange: function onChange(e) { + var val = e.target.value; + var page = val - 1; + if (val === '') { + return _this2.setState({ page: val }); + } + _this2.setState({ page: _this2.getSafePage(page) }); + }, + value: this.state.page === '' ? '' : this.state.page + 1, + onBlur: this.applyPage, + onKeyPress: function onKeyPress(e) { + if (e.which === 13 || e.keyCode === 13) { + _this2.applyPage(); + } + } + }) + ) : React.createElement( + 'span', + { className: '-currentPage' }, + page + 1 + ), + ' ', + this.props.ofText, + ' ', + React.createElement( + 'span', + { className: '-totalPages' }, + pages || 1 + ) + ), + showPageSizeOptions && React.createElement( + 'span', + { className: 'select-wrap -pageSizeOptions' }, + React.createElement( + 'select', + { onChange: function onChange(e) { + return onPageSizeChange(Number(e.target.value)); + }, value: pageSize }, + pageSizeOptions.map(function (option, i) { + return ( + // eslint-disable-next-line react/no-array-index-key + React.createElement( + 'option', + { key: i, value: option }, + option + ' ' + _this2.props.rowsText + ) + ); + }) + ) + ) + ), + React.createElement( + 'div', + { className: '-next' }, + React.createElement( + NextComponent, + { + onClick: function onClick() { + if (!canNext) return; + _this2.changePage(page + 1); + }, + disabled: !canNext + }, + this.props.nextText + ) + ) + ); + } + }]); + + return ReactTablePagination; +}(Component); + +export default ReactTablePagination; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/pagination.js"],"names":["React","Component","classnames","defaultButton","props","children","ReactTablePagination","getSafePage","bind","changePage","applyPage","state","page","nextProps","setState","Number","isNaN","Math","min","max","pages","onPageChange","e","preventDefault","showPageSizeOptions","pageSizeOptions","pageSize","showPageJump","canPrevious","canNext","onPageSizeChange","className","PreviousComponent","NextComponent","style","previousText","pageText","val","target","value","which","keyCode","ofText","map","option","i","rowsText","nextText"],"mappings":"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","file":"pagination.js","sourcesContent":["import React, { Component } from 'react'\nimport classnames from 'classnames'\n//\n// import _ from './utils'\n\nconst defaultButton = props => (\n  <button type=\"button\" {...props} className=\"-btn\">\n    {props.children}\n  </button>\n)\n\nexport default class ReactTablePagination extends Component {\n  constructor (props) {\n    super()\n\n    this.getSafePage = this.getSafePage.bind(this)\n    this.changePage = this.changePage.bind(this)\n    this.applyPage = this.applyPage.bind(this)\n\n    this.state = {\n      page: props.page,\n    }\n  }\n\n  componentWillReceiveProps (nextProps) {\n    this.setState({ page: nextProps.page })\n  }\n\n  getSafePage (page) {\n    if (Number.isNaN(page)) {\n      page = this.props.page\n    }\n    return Math.min(Math.max(page, 0), this.props.pages - 1)\n  }\n\n  changePage (page) {\n    page = this.getSafePage(page)\n    this.setState({ page })\n    if (this.props.page !== page) {\n      this.props.onPageChange(page)\n    }\n  }\n\n  applyPage (e) {\n    if (e) {\n      e.preventDefault()\n    }\n    const page = this.state.page\n    this.changePage(page === '' ? this.props.page : page)\n  }\n\n  render () {\n    const {\n      // Computed\n      pages,\n      // Props\n      page,\n      showPageSizeOptions,\n      pageSizeOptions,\n      pageSize,\n      showPageJump,\n      canPrevious,\n      canNext,\n      onPageSizeChange,\n      className,\n      PreviousComponent = defaultButton,\n      NextComponent = defaultButton,\n    } = this.props\n\n    return (\n      <div className={classnames(className, '-pagination')} style={this.props.style}>\n        <div className=\"-previous\">\n          <PreviousComponent\n            onClick={() => {\n              if (!canPrevious) return\n              this.changePage(page - 1)\n            }}\n            disabled={!canPrevious}\n          >\n            {this.props.previousText}\n          </PreviousComponent>\n        </div>\n        <div className=\"-center\">\n          <span className=\"-pageInfo\">\n            {this.props.pageText}{' '}\n            {showPageJump ? (\n              <div className=\"-pageJump\">\n                <input\n                  type={this.state.page === '' ? 'text' : 'number'}\n                  onChange={e => {\n                    const val = e.target.value\n                    const page = val - 1\n                    if (val === '') {\n                      return this.setState({ page: val })\n                    }\n                    this.setState({ page: this.getSafePage(page) })\n                  }}\n                  value={this.state.page === '' ? '' : this.state.page + 1}\n                  onBlur={this.applyPage}\n                  onKeyPress={e => {\n                    if (e.which === 13 || e.keyCode === 13) {\n                      this.applyPage()\n                    }\n                  }}\n                />\n              </div>\n            ) : (\n              <span className=\"-currentPage\">{page + 1}</span>\n            )}{' '}\n            {this.props.ofText} <span className=\"-totalPages\">{pages || 1}</span>\n          </span>\n          {showPageSizeOptions && (\n            <span className=\"select-wrap -pageSizeOptions\">\n              <select onChange={e => onPageSizeChange(Number(e.target.value))} value={pageSize}>\n                {pageSizeOptions.map((option, i) => (\n                  // eslint-disable-next-line react/no-array-index-key\n                  <option key={i} value={option}>\n                    {`${option} ${this.props.rowsText}`}\n                  </option>\n                ))}\n              </select>\n            </span>\n          )}\n        </div>\n        <div className=\"-next\">\n          <NextComponent\n            onClick={() => {\n              if (!canNext) return\n              this.changePage(page + 1)\n            }}\n            disabled={!canNext}\n          >\n            {this.props.nextText}\n          </NextComponent>\n        </div>\n      </div>\n    )\n  }\n}\n"]} \ No newline at end of file diff --git a/es/propTypes.js b/es/propTypes.js new file mode 100644 index 0000000000..e5202c765b --- /dev/null +++ b/es/propTypes.js @@ -0,0 +1,165 @@ +import PropTypes from 'prop-types'; + +export default { + // General + data: PropTypes.any, + loading: PropTypes.bool, + showPagination: PropTypes.bool, + showPaginationTop: PropTypes.bool, + showPaginationBottom: PropTypes.bool, + showPageSizeOptions: PropTypes.bool, + pageSizeOptions: PropTypes.array, + defaultPageSize: PropTypes.number, + showPageJump: PropTypes.bool, + collapseOnSortingChange: PropTypes.bool, + collapseOnPageChange: PropTypes.bool, + collapseOnDataChange: PropTypes.bool, + freezeWhenExpanded: PropTypes.bool, + sortable: PropTypes.bool, + resizable: PropTypes.bool, + filterable: PropTypes.bool, + defaultSortDesc: PropTypes.bool, + defaultSorted: PropTypes.array, + defaultFiltered: PropTypes.array, + defaultResized: PropTypes.array, + defaultExpanded: PropTypes.object, + defaultFilterMethod: PropTypes.func, + defaultSortMethod: PropTypes.func, + + // Controlled State Callbacks + onPageChange: PropTypes.func, + onPageSizeChange: PropTypes.func, + onSortedChange: PropTypes.func, + onFilteredChange: PropTypes.func, + onResizedChange: PropTypes.func, + onExpandedChange: PropTypes.func, + + // Pivoting + pivotBy: PropTypes.array, + + // Key Constants + pivotValKey: PropTypes.string, + pivotIDKey: PropTypes.string, + subRowsKey: PropTypes.string, + aggregatedKey: PropTypes.string, + nestingLevelKey: PropTypes.string, + originalKey: PropTypes.string, + indexKey: PropTypes.string, + groupedByPivotKey: PropTypes.string, + + // Server-side Callbacks + onFetchData: PropTypes.func, + + // Classes + className: PropTypes.string, + style: PropTypes.object, + + // Component decorators + getProps: PropTypes.func, + getTableProps: PropTypes.func, + getTheadGroupProps: PropTypes.func, + getTheadGroupTrProps: PropTypes.func, + getTheadGroupThProps: PropTypes.func, + getTheadProps: PropTypes.func, + getTheadTrProps: PropTypes.func, + getTheadThProps: PropTypes.func, + getTheadFilterProps: PropTypes.func, + getTheadFilterTrProps: PropTypes.func, + getTheadFilterThProps: PropTypes.func, + getTbodyProps: PropTypes.func, + getTrGroupProps: PropTypes.func, + getTrProps: PropTypes.func, + getTdProps: PropTypes.func, + getTfootProps: PropTypes.func, + getTfootTrProps: PropTypes.func, + getTfootTdProps: PropTypes.func, + getPaginationProps: PropTypes.func, + getLoadingProps: PropTypes.func, + getNoDataProps: PropTypes.func, + getResizerProps: PropTypes.func, + + // Global Column Defaults + columns: PropTypes.arrayOf(PropTypes.shape({ + // Renderers + Cell: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]), + Header: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]), + Footer: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]), + Aggregated: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]), + Pivot: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]), + PivotValue: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]), + Expander: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]), + Filter: PropTypes.oneOfType([PropTypes.element, PropTypes.func]), + + // All Columns + sortable: PropTypes.bool, // use table default + resizable: PropTypes.bool, // use table default + filterable: PropTypes.bool, // use table default + show: PropTypes.bool, + minWidth: PropTypes.number, + + // Cells only + className: PropTypes.string, + style: PropTypes.object, + getProps: PropTypes.func, + + // Pivot only + aggregate: PropTypes.func, + + // Headers only + headerClassName: PropTypes.string, + headerStyle: PropTypes.object, + getHeaderProps: PropTypes.func, + + // Footers only + footerClassName: PropTypes.string, + footerStyle: PropTypes.object, + getFooterProps: PropTypes.object, + filterMethod: PropTypes.func, + filterAll: PropTypes.bool, + sortMethod: PropTypes.func + })), + + // Global Expander Column Defaults + expanderDefaults: PropTypes.shape({ + sortable: PropTypes.bool, + resizable: PropTypes.bool, + filterable: PropTypes.bool, + width: PropTypes.number + }), + + pivotDefaults: PropTypes.object, + + // Text + previousText: PropTypes.node, + nextText: PropTypes.node, + loadingText: PropTypes.node, + noDataText: PropTypes.node, + pageText: PropTypes.node, + ofText: PropTypes.node, + rowsText: PropTypes.node, + + // Components + TableComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]), + TheadComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]), + TbodyComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]), + TrGroupComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]), + TrComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]), + ThComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]), + TdComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]), + TfootComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]), + FilterComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]), + ExpanderComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]), + PivotValueComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]), + AggregatedComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]), + // this is a computed default generated using + PivotComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]), + // the ExpanderComponent and PivotValueComponent at run-time in methods.js + PaginationComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]), + PreviousComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]), + NextComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]), + LoadingComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]), + NoDataComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]), + ResizerComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]), + PadRowComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]) +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/propTypes.js"],"names":["PropTypes","data","any","loading","bool","showPagination","showPaginationTop","showPaginationBottom","showPageSizeOptions","pageSizeOptions","array","defaultPageSize","number","showPageJump","collapseOnSortingChange","collapseOnPageChange","collapseOnDataChange","freezeWhenExpanded","sortable","resizable","filterable","defaultSortDesc","defaultSorted","defaultFiltered","defaultResized","defaultExpanded","object","defaultFilterMethod","func","defaultSortMethod","onPageChange","onPageSizeChange","onSortedChange","onFilteredChange","onResizedChange","onExpandedChange","pivotBy","pivotValKey","string","pivotIDKey","subRowsKey","aggregatedKey","nestingLevelKey","originalKey","indexKey","groupedByPivotKey","onFetchData","className","style","getProps","getTableProps","getTheadGroupProps","getTheadGroupTrProps","getTheadGroupThProps","getTheadProps","getTheadTrProps","getTheadThProps","getTheadFilterProps","getTheadFilterTrProps","getTheadFilterThProps","getTbodyProps","getTrGroupProps","getTrProps","getTdProps","getTfootProps","getTfootTrProps","getTfootTdProps","getPaginationProps","getLoadingProps","getNoDataProps","getResizerProps","columns","arrayOf","shape","Cell","oneOfType","element","Header","Footer","Aggregated","Pivot","PivotValue","Expander","Filter","show","minWidth","aggregate","headerClassName","headerStyle","getHeaderProps","footerClassName","footerStyle","getFooterProps","filterMethod","filterAll","sortMethod","expanderDefaults","width","pivotDefaults","previousText","node","nextText","loadingText","noDataText","pageText","ofText","rowsText","TableComponent","TheadComponent","TbodyComponent","TrGroupComponent","TrComponent","ThComponent","TdComponent","TfootComponent","FilterComponent","ExpanderComponent","PivotValueComponent","AggregatedComponent","PivotComponent","PaginationComponent","PreviousComponent","NextComponent","LoadingComponent","NoDataComponent","ResizerComponent","PadRowComponent"],"mappings":"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","file":"propTypes.js","sourcesContent":["import PropTypes from 'prop-types'\n\nexport default {\n  // General\n  data: PropTypes.any,\n  loading: PropTypes.bool,\n  showPagination: PropTypes.bool,\n  showPaginationTop: PropTypes.bool,\n  showPaginationBottom: PropTypes.bool,\n  showPageSizeOptions: PropTypes.bool,\n  pageSizeOptions: PropTypes.array,\n  defaultPageSize: PropTypes.number,\n  showPageJump: PropTypes.bool,\n  collapseOnSortingChange: PropTypes.bool,\n  collapseOnPageChange: PropTypes.bool,\n  collapseOnDataChange: PropTypes.bool,\n  freezeWhenExpanded: PropTypes.bool,\n  sortable: PropTypes.bool,\n  resizable: PropTypes.bool,\n  filterable: PropTypes.bool,\n  defaultSortDesc: PropTypes.bool,\n  defaultSorted: PropTypes.array,\n  defaultFiltered: PropTypes.array,\n  defaultResized: PropTypes.array,\n  defaultExpanded: PropTypes.object,\n  defaultFilterMethod: PropTypes.func,\n  defaultSortMethod: PropTypes.func,\n\n  // Controlled State Callbacks\n  onPageChange: PropTypes.func,\n  onPageSizeChange: PropTypes.func,\n  onSortedChange: PropTypes.func,\n  onFilteredChange: PropTypes.func,\n  onResizedChange: PropTypes.func,\n  onExpandedChange: PropTypes.func,\n\n  // Pivoting\n  pivotBy: PropTypes.array,\n\n  // Key Constants\n  pivotValKey: PropTypes.string,\n  pivotIDKey: PropTypes.string,\n  subRowsKey: PropTypes.string,\n  aggregatedKey: PropTypes.string,\n  nestingLevelKey: PropTypes.string,\n  originalKey: PropTypes.string,\n  indexKey: PropTypes.string,\n  groupedByPivotKey: PropTypes.string,\n\n  // Server-side Callbacks\n  onFetchData: PropTypes.func,\n\n  // Classes\n  className: PropTypes.string,\n  style: PropTypes.object,\n\n  // Component decorators\n  getProps: PropTypes.func,\n  getTableProps: PropTypes.func,\n  getTheadGroupProps: PropTypes.func,\n  getTheadGroupTrProps: PropTypes.func,\n  getTheadGroupThProps: PropTypes.func,\n  getTheadProps: PropTypes.func,\n  getTheadTrProps: PropTypes.func,\n  getTheadThProps: PropTypes.func,\n  getTheadFilterProps: PropTypes.func,\n  getTheadFilterTrProps: PropTypes.func,\n  getTheadFilterThProps: PropTypes.func,\n  getTbodyProps: PropTypes.func,\n  getTrGroupProps: PropTypes.func,\n  getTrProps: PropTypes.func,\n  getTdProps: PropTypes.func,\n  getTfootProps: PropTypes.func,\n  getTfootTrProps: PropTypes.func,\n  getTfootTdProps: PropTypes.func,\n  getPaginationProps: PropTypes.func,\n  getLoadingProps: PropTypes.func,\n  getNoDataProps: PropTypes.func,\n  getResizerProps: PropTypes.func,\n\n  // Global Column Defaults\n  columns: PropTypes.arrayOf(\n    PropTypes.shape({\n      // Renderers\n      Cell: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]),\n      Header: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]),\n      Footer: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]),\n      Aggregated: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]),\n      Pivot: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]),\n      PivotValue: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]),\n      Expander: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]),\n      Filter: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),\n\n      // All Columns\n      sortable: PropTypes.bool, // use table default\n      resizable: PropTypes.bool, // use table default\n      filterable: PropTypes.bool, // use table default\n      show: PropTypes.bool,\n      minWidth: PropTypes.number,\n\n      // Cells only\n      className: PropTypes.string,\n      style: PropTypes.object,\n      getProps: PropTypes.func,\n\n      // Pivot only\n      aggregate: PropTypes.func,\n\n      // Headers only\n      headerClassName: PropTypes.string,\n      headerStyle: PropTypes.object,\n      getHeaderProps: PropTypes.func,\n\n      // Footers only\n      footerClassName: PropTypes.string,\n      footerStyle: PropTypes.object,\n      getFooterProps: PropTypes.object,\n      filterMethod: PropTypes.func,\n      filterAll: PropTypes.bool,\n      sortMethod: PropTypes.func,\n    })\n  ),\n\n  // Global Expander Column Defaults\n  expanderDefaults: PropTypes.shape({\n    sortable: PropTypes.bool,\n    resizable: PropTypes.bool,\n    filterable: PropTypes.bool,\n    width: PropTypes.number,\n  }),\n\n  pivotDefaults: PropTypes.object,\n\n  // Text\n  previousText: PropTypes.node,\n  nextText: PropTypes.node,\n  loadingText: PropTypes.node,\n  noDataText: PropTypes.node,\n  pageText: PropTypes.node,\n  ofText: PropTypes.node,\n  rowsText: PropTypes.node,\n\n  // Components\n  TableComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  TheadComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  TbodyComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  TrGroupComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  TrComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  ThComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  TdComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  TfootComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  FilterComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  ExpanderComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  PivotValueComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  AggregatedComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  // this is a computed default generated using\n  PivotComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  // the ExpanderComponent and PivotValueComponent at run-time in methods.js\n  PaginationComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  PreviousComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  NextComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  LoadingComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  NoDataComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  ResizerComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  PadRowComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n}\n"]} \ No newline at end of file diff --git a/es/utils.js b/es/utils.js new file mode 100644 index 0000000000..6b34e49108 --- /dev/null +++ b/es/utils.js @@ -0,0 +1,226 @@ +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; }; + +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; } + +import React from 'react'; +import classnames from 'classnames'; +// +export default { + get: get, + set: set, + takeRight: takeRight, + last: last, + orderBy: orderBy, + range: range, + remove: remove, + clone: clone, + getFirstDefined: getFirstDefined, + sum: sum, + makeTemplateComponent: makeTemplateComponent, + groupBy: groupBy, + isArray: isArray, + splitProps: splitProps, + compactObject: compactObject, + isSortingDesc: isSortingDesc, + normalizeComponent: normalizeComponent, + asPx: asPx +}; + +function get(obj, path, def) { + if (!path) { + return obj; + } + var pathObj = makePathArray(path); + var val = void 0; + try { + val = pathObj.reduce(function (current, pathPart) { + return current[pathPart]; + }, obj); + } catch (e) { + // continue regardless of error + } + return typeof val !== 'undefined' ? val : def; +} + +function set() { + var obj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var path = arguments[1]; + var value = arguments[2]; + + var keys = makePathArray(path); + var keyPart = void 0; + var cursor = obj; + while ((keyPart = keys.shift()) && keys.length) { + if (!cursor[keyPart]) { + cursor[keyPart] = {}; + } + cursor = cursor[keyPart]; + } + cursor[keyPart] = value; + return obj; +} + +function takeRight(arr, n) { + var start = n > arr.length ? 0 : arr.length - n; + return arr.slice(start); +} + +function last(arr) { + return arr[arr.length - 1]; +} + +function range(n) { + var arr = []; + for (var i = 0; i < n; i += 1) { + arr.push(n); + } + return arr; +} + +function orderBy(arr, funcs, dirs, indexKey) { + return arr.sort(function (rowA, rowB) { + for (var i = 0; i < funcs.length; i += 1) { + var comp = funcs[i]; + var desc = dirs[i] === false || dirs[i] === 'desc'; + var sortInt = comp(rowA, rowB); + if (sortInt) { + return desc ? -sortInt : sortInt; + } + } + // Use the row index for tie breakers + return dirs[0] ? rowA[indexKey] - rowB[indexKey] : rowB[indexKey] - rowA[indexKey]; + }); +} + +function remove(a, b) { + return a.filter(function (o, i) { + var r = b(o); + if (r) { + a.splice(i, 1); + return true; + } + return false; + }); +} + +function clone(a) { + try { + return JSON.parse(JSON.stringify(a, function (key, value) { + if (typeof value === 'function') { + return value.toString(); + } + return value; + })); + } catch (e) { + return a; + } +} + +function getFirstDefined() { + for (var i = 0; i < arguments.length; i += 1) { + if (typeof (arguments.length <= i ? undefined : arguments[i]) !== 'undefined') { + return arguments.length <= i ? undefined : arguments[i]; + } + } +} + +function sum(arr) { + return arr.reduce(function (a, b) { + return a + b; + }, 0); +} + +function makeTemplateComponent(compClass, displayName) { + if (!displayName) { + throw new Error('No displayName found for template component:', compClass); + } + var cmp = function cmp(_ref) { + var children = _ref.children, + className = _ref.className, + rest = _objectWithoutProperties(_ref, ['children', 'className']); + + return React.createElement( + 'div', + _extends({ className: classnames(compClass, className) }, rest), + children + ); + }; + cmp.displayName = displayName; + return cmp; +} + +function groupBy(xs, key) { + return xs.reduce(function (rv, x, i) { + var resKey = typeof key === 'function' ? key(x, i) : x[key]; + rv[resKey] = isArray(rv[resKey]) ? rv[resKey] : []; + rv[resKey].push(x); + return rv; + }, {}); +} + +function asPx(value) { + value = Number(value); + return Number.isNaN(value) ? null : value + 'px'; +} + +function isArray(a) { + return Array.isArray(a); +} + +// ######################################################################## +// Non-exported Helpers +// ######################################################################## + +function makePathArray(obj) { + return flattenDeep(obj).join('.').replace(/\[/g, '.').replace(/\]/g, '').split('.'); +} + +function flattenDeep(arr) { + var newArr = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + + if (!isArray(arr)) { + newArr.push(arr); + } else { + for (var i = 0; i < arr.length; i += 1) { + flattenDeep(arr[i], newArr); + } + } + return newArr; +} + +function splitProps(_ref2) { + var className = _ref2.className, + style = _ref2.style, + rest = _objectWithoutProperties(_ref2, ['className', 'style']); + + return { + className: className, + style: style, + rest: rest || {} + }; +} + +function compactObject(obj) { + var newObj = {}; + if (obj) { + Object.keys(obj).map(function (key) { + if (Object.prototype.hasOwnProperty.call(obj, key) && obj[key] !== undefined && typeof obj[key] !== 'undefined') { + newObj[key] = obj[key]; + } + return true; + }); + } + return newObj; +} + +function isSortingDesc(d) { + return !!(d.sort === 'desc' || d.desc === true || d.asc === false); +} + +function normalizeComponent(Comp) { + var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var fallback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Comp; + + return typeof Comp === 'function' ? Object.getPrototypeOf(Comp).isReactComponent ? React.createElement(Comp, params) : Comp(params) : fallback; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/utils.js"],"names":["React","classnames","get","set","takeRight","last","orderBy","range","remove","clone","getFirstDefined","sum","makeTemplateComponent","groupBy","isArray","splitProps","compactObject","isSortingDesc","normalizeComponent","asPx","obj","path","def","pathObj","makePathArray","val","reduce","current","pathPart","e","value","keys","keyPart","cursor","shift","length","arr","n","start","slice","i","push","funcs","dirs","indexKey","sort","rowA","rowB","comp","desc","sortInt","a","b","filter","o","r","splice","JSON","parse","stringify","key","toString","compClass","displayName","Error","cmp","children","className","rest","xs","rv","x","resKey","Number","isNaN","Array","flattenDeep","join","replace","split","newArr","style","newObj","Object","map","prototype","hasOwnProperty","call","undefined","d","asc","Comp","params","fallback","getPrototypeOf","isReactComponent"],"mappings":"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","file":"utils.js","sourcesContent":["import React from 'react'\nimport classnames from 'classnames'\n//\nexport default {\n  get,\n  set,\n  takeRight,\n  last,\n  orderBy,\n  range,\n  remove,\n  clone,\n  getFirstDefined,\n  sum,\n  makeTemplateComponent,\n  groupBy,\n  isArray,\n  splitProps,\n  compactObject,\n  isSortingDesc,\n  normalizeComponent,\n  asPx,\n}\n\nfunction get (obj, path, def) {\n  if (!path) {\n    return obj\n  }\n  const pathObj = makePathArray(path)\n  let val\n  try {\n    val = pathObj.reduce((current, pathPart) => current[pathPart], obj)\n  } catch (e) {\n    // continue regardless of error\n  }\n  return typeof val !== 'undefined' ? val : def\n}\n\nfunction set (obj = {}, path, value) {\n  const keys = makePathArray(path)\n  let keyPart\n  let cursor = obj\n  while ((keyPart = keys.shift()) && keys.length) {\n    if (!cursor[keyPart]) {\n      cursor[keyPart] = {}\n    }\n    cursor = cursor[keyPart]\n  }\n  cursor[keyPart] = value\n  return obj\n}\n\nfunction takeRight (arr, n) {\n  const start = n > arr.length ? 0 : arr.length - n\n  return arr.slice(start)\n}\n\nfunction last (arr) {\n  return arr[arr.length - 1]\n}\n\nfunction range (n) {\n  const arr = []\n  for (let i = 0; i < n; i += 1) {\n    arr.push(n)\n  }\n  return arr\n}\n\nfunction orderBy (arr, funcs, dirs, indexKey) {\n  return arr.sort((rowA, rowB) => {\n    for (let i = 0; i < funcs.length; i += 1) {\n      const comp = funcs[i]\n      const desc = dirs[i] === false || dirs[i] === 'desc'\n      const sortInt = comp(rowA, rowB)\n      if (sortInt) {\n        return desc ? -sortInt : sortInt\n      }\n    }\n    // Use the row index for tie breakers\n    return dirs[0] ? rowA[indexKey] - rowB[indexKey] : rowB[indexKey] - rowA[indexKey]\n  })\n}\n\nfunction remove (a, b) {\n  return a.filter((o, i) => {\n    const r = b(o)\n    if (r) {\n      a.splice(i, 1)\n      return true\n    }\n    return false\n  })\n}\n\nfunction clone (a) {\n  try {\n    return JSON.parse(\n      JSON.stringify(a, (key, value) => {\n        if (typeof value === 'function') {\n          return value.toString()\n        }\n        return value\n      })\n    )\n  } catch (e) {\n    return a\n  }\n}\n\nfunction getFirstDefined (...args) {\n  for (let i = 0; i < args.length; i += 1) {\n    if (typeof args[i] !== 'undefined') {\n      return args[i]\n    }\n  }\n}\n\nfunction sum (arr) {\n  return arr.reduce((a, b) => a + b, 0)\n}\n\nfunction makeTemplateComponent (compClass, displayName) {\n  if (!displayName) {\n    throw new Error('No displayName found for template component:', compClass)\n  }\n  const cmp = ({ children, className, ...rest }) => (\n    <div className={classnames(compClass, className)} {...rest}>\n      {children}\n    </div>\n  )\n  cmp.displayName = displayName\n  return cmp\n}\n\nfunction groupBy (xs, key) {\n  return xs.reduce((rv, x, i) => {\n    const resKey = typeof key === 'function' ? key(x, i) : x[key]\n    rv[resKey] = isArray(rv[resKey]) ? rv[resKey] : []\n    rv[resKey].push(x)\n    return rv\n  }, {})\n}\n\nfunction asPx (value) {\n  value = Number(value)\n  return Number.isNaN(value) ? null : `${value}px`\n}\n\nfunction isArray (a) {\n  return Array.isArray(a)\n}\n\n// ########################################################################\n// Non-exported Helpers\n// ########################################################################\n\nfunction makePathArray (obj) {\n  return flattenDeep(obj)\n    .join('.')\n    .replace(/\\[/g, '.')\n    .replace(/\\]/g, '')\n    .split('.')\n}\n\nfunction flattenDeep (arr, newArr = []) {\n  if (!isArray(arr)) {\n    newArr.push(arr)\n  } else {\n    for (let i = 0; i < arr.length; i += 1) {\n      flattenDeep(arr[i], newArr)\n    }\n  }\n  return newArr\n}\n\nfunction splitProps ({ className, style, ...rest }) {\n  return {\n    className,\n    style,\n    rest: rest || {},\n  }\n}\n\nfunction compactObject (obj) {\n  const newObj = {}\n  if (obj) {\n    Object.keys(obj).map(key => {\n      if (\n        Object.prototype.hasOwnProperty.call(obj, key) &&\n        obj[key] !== undefined &&\n        typeof obj[key] !== 'undefined'\n      ) {\n        newObj[key] = obj[key]\n      }\n      return true\n    })\n  }\n  return newObj\n}\n\nfunction isSortingDesc (d) {\n  return !!(d.sort === 'desc' || d.desc === true || d.asc === false)\n}\n\nfunction normalizeComponent (Comp, params = {}, fallback = Comp) {\n  return typeof Comp === 'function' ? (\n    Object.getPrototypeOf(Comp).isReactComponent ? (\n      <Comp {...params} />\n    ) : (\n      Comp(params)\n    )\n  ) : (\n    fallback\n  )\n}\n"]} \ No newline at end of file diff --git a/lib/defaultProps.js b/lib/defaultProps.js new file mode 100644 index 0000000000..fe7943355a --- /dev/null +++ b/lib/defaultProps.js @@ -0,0 +1,369 @@ +'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 _react = require('react'); + +var _react2 = _interopRequireDefault(_react); + +var _classnames = require('classnames'); + +var _classnames2 = _interopRequireDefault(_classnames); + +var _utils = require('./utils'); + +var _utils2 = _interopRequireDefault(_utils); + +var _pagination = require('./pagination'); + +var _pagination2 = _interopRequireDefault(_pagination); + +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 emptyObj = function emptyObj() { + return {}; +}; + +exports.default = { + // General + data: [], + resolveData: function resolveData(data) { + return data; + }, + loading: false, + showPagination: true, + showPaginationTop: false, + showPaginationBottom: true, + showPageSizeOptions: true, + pageSizeOptions: [5, 10, 20, 25, 50, 100], + defaultPage: 0, + defaultPageSize: 20, + showPageJump: true, + collapseOnSortingChange: true, + collapseOnPageChange: true, + collapseOnDataChange: true, + freezeWhenExpanded: false, + sortable: true, + multiSort: true, + resizable: true, + filterable: false, + defaultSortDesc: false, + defaultSorted: [], + defaultFiltered: [], + defaultResized: [], + defaultExpanded: {}, + // eslint-disable-next-line no-unused-vars + defaultFilterMethod: function defaultFilterMethod(filter, row, column) { + var id = filter.pivotId || filter.id; + return row[id] !== undefined ? String(row[id]).startsWith(filter.value) : true; + }, + // eslint-disable-next-line no-unused-vars + defaultSortMethod: function defaultSortMethod(a, b, desc) { + // force null and undefined to the bottom + a = a === null || a === undefined ? '' : a; + b = b === null || b === undefined ? '' : b; + // force any string values to lowercase + a = typeof a === 'string' ? a.toLowerCase() : a; + b = typeof b === 'string' ? b.toLowerCase() : b; + // Return either 1 or -1 to indicate a sort priority + if (a > b) { + return 1; + } + if (a < b) { + return -1; + } + // returning 0, undefined or any falsey value will use subsequent sorts or + // the index as a tiebreaker + return 0; + }, + + // Controlled State Props + // page: undefined, + // pageSize: undefined, + // sorted: [], + // filtered: [], + // resized: [], + // expanded: {}, + + // Controlled State Callbacks + onPageChange: undefined, + onPageSizeChange: undefined, + onSortedChange: undefined, + onFilteredChange: undefined, + onResizedChange: undefined, + onExpandedChange: undefined, + + // Pivoting + pivotBy: undefined, + + // Key Constants + pivotValKey: '_pivotVal', + pivotIDKey: '_pivotID', + subRowsKey: '_subRows', + aggregatedKey: '_aggregated', + nestingLevelKey: '_nestingLevel', + originalKey: '_original', + indexKey: '_index', + groupedByPivotKey: '_groupedByPivot', + + // Server-side Callbacks + onFetchData: function onFetchData() { + return null; + }, + + // Classes + className: '', + style: {}, + + // Component decorators + getProps: emptyObj, + getTableProps: emptyObj, + getTheadGroupProps: emptyObj, + getTheadGroupTrProps: emptyObj, + getTheadGroupThProps: emptyObj, + getTheadProps: emptyObj, + getTheadTrProps: emptyObj, + getTheadThProps: emptyObj, + getTheadFilterProps: emptyObj, + getTheadFilterTrProps: emptyObj, + getTheadFilterThProps: emptyObj, + getTbodyProps: emptyObj, + getTrGroupProps: emptyObj, + getTrProps: emptyObj, + getTdProps: emptyObj, + getTfootProps: emptyObj, + getTfootTrProps: emptyObj, + getTfootTdProps: emptyObj, + getPaginationProps: emptyObj, + getLoadingProps: emptyObj, + getNoDataProps: emptyObj, + getResizerProps: emptyObj, + + // Global Column Defaults + column: { + // Renderers + Cell: undefined, + Header: undefined, + Footer: undefined, + Aggregated: undefined, + Pivot: undefined, + PivotValue: undefined, + Expander: undefined, + Filter: undefined, + // All Columns + sortable: undefined, // use table default + resizable: undefined, // use table default + filterable: undefined, // use table default + show: true, + minWidth: 100, + // Cells only + className: '', + style: {}, + getProps: emptyObj, + // Pivot only + aggregate: undefined, + // Headers only + headerClassName: '', + headerStyle: {}, + getHeaderProps: emptyObj, + // Footers only + footerClassName: '', + footerStyle: {}, + getFooterProps: emptyObj, + filterMethod: undefined, + filterAll: false, + sortMethod: undefined + }, + + // Global Expander Column Defaults + expanderDefaults: { + sortable: false, + resizable: false, + filterable: false, + width: 35 + }, + + pivotDefaults: { + // extend the defaults for pivoted columns here + }, + + // Text + previousText: 'Previous', + nextText: 'Next', + loadingText: 'Loading...', + noDataText: 'No rows found', + pageText: 'Page', + ofText: 'of', + rowsText: 'rows', + + // Components + TableComponent: function TableComponent(_ref) { + var children = _ref.children, + className = _ref.className, + rest = _objectWithoutProperties(_ref, ['children', 'className']); + + return _react2.default.createElement( + 'div', + _extends({ + className: (0, _classnames2.default)('rt-table', className), + role: 'grid' + // tabIndex='0' + }, rest), + children + ); + }, + TheadComponent: _utils2.default.makeTemplateComponent('rt-thead', 'Thead'), + TbodyComponent: _utils2.default.makeTemplateComponent('rt-tbody', 'Tbody'), + TrGroupComponent: function TrGroupComponent(_ref2) { + var children = _ref2.children, + className = _ref2.className, + rest = _objectWithoutProperties(_ref2, ['children', 'className']); + + return _react2.default.createElement( + 'div', + _extends({ className: (0, _classnames2.default)('rt-tr-group', className), role: 'rowgroup' }, rest), + children + ); + }, + TrComponent: function TrComponent(_ref3) { + var children = _ref3.children, + className = _ref3.className, + rest = _objectWithoutProperties(_ref3, ['children', 'className']); + + return _react2.default.createElement( + 'div', + _extends({ className: (0, _classnames2.default)('rt-tr', className), role: 'row' }, rest), + children + ); + }, + ThComponent: function ThComponent(_ref4) { + var toggleSort = _ref4.toggleSort, + className = _ref4.className, + children = _ref4.children, + rest = _objectWithoutProperties(_ref4, ['toggleSort', 'className', 'children']); + + return ( + // eslint-disable-next-line jsx-a11y/click-events-have-key-events + _react2.default.createElement( + 'div', + _extends({ + className: (0, _classnames2.default)('rt-th', className), + onClick: function onClick(e) { + return toggleSort && toggleSort(e); + }, + role: 'columnheader', + tabIndex: '-1' // Resolves eslint issues without implementing keyboard navigation incorrectly + }, rest), + children + ) + ); + }, + TdComponent: function TdComponent(_ref5) { + var toggleSort = _ref5.toggleSort, + className = _ref5.className, + children = _ref5.children, + rest = _objectWithoutProperties(_ref5, ['toggleSort', 'className', 'children']); + + return _react2.default.createElement( + 'div', + _extends({ className: (0, _classnames2.default)('rt-td', className), role: 'gridcell' }, rest), + children + ); + }, + TfootComponent: _utils2.default.makeTemplateComponent('rt-tfoot', 'Tfoot'), + FilterComponent: function FilterComponent(_ref6) { + var filter = _ref6.filter, + _onChange = _ref6.onChange; + return _react2.default.createElement('input', { + type: 'text', + style: { + width: '100%' + }, + value: filter ? filter.value : '', + onChange: function onChange(event) { + return _onChange(event.target.value); + } + }); + }, + ExpanderComponent: function ExpanderComponent(_ref7) { + var isExpanded = _ref7.isExpanded; + return _react2.default.createElement( + 'div', + { className: (0, _classnames2.default)('rt-expander', isExpanded && '-open') }, + '\u2022' + ); + }, + PivotValueComponent: function PivotValueComponent(_ref8) { + var subRows = _ref8.subRows, + value = _ref8.value; + return _react2.default.createElement( + 'span', + null, + value, + ' ', + subRows && '(' + subRows.length + ')' + ); + }, + AggregatedComponent: function AggregatedComponent(_ref9) { + var subRows = _ref9.subRows, + column = _ref9.column; + + var previewValues = subRows.filter(function (d) { + return typeof d[column.id] !== 'undefined'; + }).map(function (row, i) { + return ( + // eslint-disable-next-line react/no-array-index-key + _react2.default.createElement( + 'span', + { key: i }, + row[column.id], + i < subRows.length - 1 ? ', ' : '' + ) + ); + }); + return _react2.default.createElement( + 'span', + null, + previewValues + ); + }, + PivotComponent: undefined, // this is a computed default generated using + // the ExpanderComponent and PivotValueComponent at run-time in methods.js + PaginationComponent: _pagination2.default, + PreviousComponent: undefined, + NextComponent: undefined, + LoadingComponent: function LoadingComponent(_ref10) { + var className = _ref10.className, + loading = _ref10.loading, + loadingText = _ref10.loadingText, + rest = _objectWithoutProperties(_ref10, ['className', 'loading', 'loadingText']); + + return _react2.default.createElement( + 'div', + _extends({ className: (0, _classnames2.default)('-loading', { '-active': loading }, className) }, rest), + _react2.default.createElement( + 'div', + { className: '-loading-inner' }, + loadingText + ) + ); + }, + NoDataComponent: _utils2.default.makeTemplateComponent('rt-noData', 'NoData'), + ResizerComponent: _utils2.default.makeTemplateComponent('rt-resizer', 'Resizer'), + PadRowComponent: function PadRowComponent() { + return _react2.default.createElement( + 'span', + null, + '\xA0' + ); + } +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/defaultProps.js"],"names":["emptyObj","data","resolveData","loading","showPagination","showPaginationTop","showPaginationBottom","showPageSizeOptions","pageSizeOptions","defaultPage","defaultPageSize","showPageJump","collapseOnSortingChange","collapseOnPageChange","collapseOnDataChange","freezeWhenExpanded","sortable","multiSort","resizable","filterable","defaultSortDesc","defaultSorted","defaultFiltered","defaultResized","defaultExpanded","defaultFilterMethod","filter","row","column","id","pivotId","undefined","String","startsWith","value","defaultSortMethod","a","b","desc","toLowerCase","onPageChange","onPageSizeChange","onSortedChange","onFilteredChange","onResizedChange","onExpandedChange","pivotBy","pivotValKey","pivotIDKey","subRowsKey","aggregatedKey","nestingLevelKey","originalKey","indexKey","groupedByPivotKey","onFetchData","className","style","getProps","getTableProps","getTheadGroupProps","getTheadGroupTrProps","getTheadGroupThProps","getTheadProps","getTheadTrProps","getTheadThProps","getTheadFilterProps","getTheadFilterTrProps","getTheadFilterThProps","getTbodyProps","getTrGroupProps","getTrProps","getTdProps","getTfootProps","getTfootTrProps","getTfootTdProps","getPaginationProps","getLoadingProps","getNoDataProps","getResizerProps","Cell","Header","Footer","Aggregated","Pivot","PivotValue","Expander","Filter","show","minWidth","aggregate","headerClassName","headerStyle","getHeaderProps","footerClassName","footerStyle","getFooterProps","filterMethod","filterAll","sortMethod","expanderDefaults","width","pivotDefaults","previousText","nextText","loadingText","noDataText","pageText","ofText","rowsText","TableComponent","children","rest","TheadComponent","_","makeTemplateComponent","TbodyComponent","TrGroupComponent","TrComponent","ThComponent","toggleSort","e","TdComponent","TfootComponent","FilterComponent","onChange","event","target","ExpanderComponent","isExpanded","PivotValueComponent","subRows","length","AggregatedComponent","previewValues","d","map","i","PivotComponent","PaginationComponent","Pagination","PreviousComponent","NextComponent","LoadingComponent","NoDataComponent","ResizerComponent","PadRowComponent"],"mappings":"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","file":"defaultProps.js","sourcesContent":["import React from 'react'\nimport classnames from 'classnames'\n//\nimport _ from './utils'\nimport Pagination from './pagination'\n\nconst emptyObj = () => ({})\n\nexport default {\n  // General\n  data: [],\n  resolveData: data => data,\n  loading: false,\n  showPagination: true,\n  showPaginationTop: false,\n  showPaginationBottom: true,\n  showPageSizeOptions: true,\n  pageSizeOptions: [5, 10, 20, 25, 50, 100],\n  defaultPage: 0,\n  defaultPageSize: 20,\n  showPageJump: true,\n  collapseOnSortingChange: true,\n  collapseOnPageChange: true,\n  collapseOnDataChange: true,\n  freezeWhenExpanded: false,\n  sortable: true,\n  multiSort: true,\n  resizable: true,\n  filterable: false,\n  defaultSortDesc: false,\n  defaultSorted: [],\n  defaultFiltered: [],\n  defaultResized: [],\n  defaultExpanded: {},\n  // eslint-disable-next-line no-unused-vars\n  defaultFilterMethod: (filter, row, column) => {\n    const id = filter.pivotId || filter.id\n    return row[id] !== undefined ? String(row[id]).startsWith(filter.value) : true\n  },\n  // eslint-disable-next-line no-unused-vars\n  defaultSortMethod: (a, b, desc) => {\n    // force null and undefined to the bottom\n    a = a === null || a === undefined ? '' : a\n    b = b === null || b === undefined ? '' : b\n    // force any string values to lowercase\n    a = typeof a === 'string' ? a.toLowerCase() : a\n    b = typeof b === 'string' ? b.toLowerCase() : b\n    // Return either 1 or -1 to indicate a sort priority\n    if (a > b) {\n      return 1\n    }\n    if (a < b) {\n      return -1\n    }\n    // returning 0, undefined or any falsey value will use subsequent sorts or\n    // the index as a tiebreaker\n    return 0\n  },\n\n  // Controlled State Props\n  // page: undefined,\n  // pageSize: undefined,\n  // sorted: [],\n  // filtered: [],\n  // resized: [],\n  // expanded: {},\n\n  // Controlled State Callbacks\n  onPageChange: undefined,\n  onPageSizeChange: undefined,\n  onSortedChange: undefined,\n  onFilteredChange: undefined,\n  onResizedChange: undefined,\n  onExpandedChange: undefined,\n\n  // Pivoting\n  pivotBy: undefined,\n\n  // Key Constants\n  pivotValKey: '_pivotVal',\n  pivotIDKey: '_pivotID',\n  subRowsKey: '_subRows',\n  aggregatedKey: '_aggregated',\n  nestingLevelKey: '_nestingLevel',\n  originalKey: '_original',\n  indexKey: '_index',\n  groupedByPivotKey: '_groupedByPivot',\n\n  // Server-side Callbacks\n  onFetchData: () => null,\n\n  // Classes\n  className: '',\n  style: {},\n\n  // Component decorators\n  getProps: emptyObj,\n  getTableProps: emptyObj,\n  getTheadGroupProps: emptyObj,\n  getTheadGroupTrProps: emptyObj,\n  getTheadGroupThProps: emptyObj,\n  getTheadProps: emptyObj,\n  getTheadTrProps: emptyObj,\n  getTheadThProps: emptyObj,\n  getTheadFilterProps: emptyObj,\n  getTheadFilterTrProps: emptyObj,\n  getTheadFilterThProps: emptyObj,\n  getTbodyProps: emptyObj,\n  getTrGroupProps: emptyObj,\n  getTrProps: emptyObj,\n  getTdProps: emptyObj,\n  getTfootProps: emptyObj,\n  getTfootTrProps: emptyObj,\n  getTfootTdProps: emptyObj,\n  getPaginationProps: emptyObj,\n  getLoadingProps: emptyObj,\n  getNoDataProps: emptyObj,\n  getResizerProps: emptyObj,\n\n  // Global Column Defaults\n  column: {\n    // Renderers\n    Cell: undefined,\n    Header: undefined,\n    Footer: undefined,\n    Aggregated: undefined,\n    Pivot: undefined,\n    PivotValue: undefined,\n    Expander: undefined,\n    Filter: undefined,\n    // All Columns\n    sortable: undefined, // use table default\n    resizable: undefined, // use table default\n    filterable: undefined, // use table default\n    show: true,\n    minWidth: 100,\n    // Cells only\n    className: '',\n    style: {},\n    getProps: emptyObj,\n    // Pivot only\n    aggregate: undefined,\n    // Headers only\n    headerClassName: '',\n    headerStyle: {},\n    getHeaderProps: emptyObj,\n    // Footers only\n    footerClassName: '',\n    footerStyle: {},\n    getFooterProps: emptyObj,\n    filterMethod: undefined,\n    filterAll: false,\n    sortMethod: undefined,\n  },\n\n  // Global Expander Column Defaults\n  expanderDefaults: {\n    sortable: false,\n    resizable: false,\n    filterable: false,\n    width: 35,\n  },\n\n  pivotDefaults: {\n    // extend the defaults for pivoted columns here\n  },\n\n  // Text\n  previousText: 'Previous',\n  nextText: 'Next',\n  loadingText: 'Loading...',\n  noDataText: 'No rows found',\n  pageText: 'Page',\n  ofText: 'of',\n  rowsText: 'rows',\n\n  // Components\n  TableComponent: ({ children, className, ...rest }) => (\n    <div\n      className={classnames('rt-table', className)}\n      role=\"grid\"\n      // tabIndex='0'\n      {...rest}\n    >\n      {children}\n    </div>\n  ),\n  TheadComponent: _.makeTemplateComponent('rt-thead', 'Thead'),\n  TbodyComponent: _.makeTemplateComponent('rt-tbody', 'Tbody'),\n  TrGroupComponent: ({ children, className, ...rest }) => (\n    <div className={classnames('rt-tr-group', className)} role=\"rowgroup\" {...rest}>\n      {children}\n    </div>\n  ),\n  TrComponent: ({ children, className, ...rest }) => (\n    <div className={classnames('rt-tr', className)} role=\"row\" {...rest}>\n      {children}\n    </div>\n  ),\n  ThComponent: ({\n    toggleSort, className, children, ...rest\n  }) => (\n    // eslint-disable-next-line jsx-a11y/click-events-have-key-events\n    <div\n      className={classnames('rt-th', className)}\n      onClick={e => toggleSort && toggleSort(e)}\n      role=\"columnheader\"\n      tabIndex=\"-1\" // Resolves eslint issues without implementing keyboard navigation incorrectly\n      {...rest}\n    >\n      {children}\n    </div>\n  ),\n  TdComponent: ({\n    toggleSort, className, children, ...rest\n  }) => (\n    <div className={classnames('rt-td', className)} role=\"gridcell\" {...rest}>\n      {children}\n    </div>\n  ),\n  TfootComponent: _.makeTemplateComponent('rt-tfoot', 'Tfoot'),\n  FilterComponent: ({ filter, onChange }) => (\n    <input\n      type=\"text\"\n      style={{\n        width: '100%',\n      }}\n      value={filter ? filter.value : ''}\n      onChange={event => onChange(event.target.value)}\n    />\n  ),\n  ExpanderComponent: ({ isExpanded }) => (\n    <div className={classnames('rt-expander', isExpanded && '-open')}>&bull;</div>\n  ),\n  PivotValueComponent: ({ subRows, value }) => (\n    <span>\n      {value} {subRows && `(${subRows.length})`}\n    </span>\n  ),\n  AggregatedComponent: ({ subRows, column }) => {\n    const previewValues = subRows.filter(d => typeof d[column.id] !== 'undefined').map((row, i) => (\n      // eslint-disable-next-line react/no-array-index-key\n      <span key={i}>\n        {row[column.id]}\n        {i < subRows.length - 1 ? ', ' : ''}\n      </span>\n    ))\n    return <span>{previewValues}</span>\n  },\n  PivotComponent: undefined, // this is a computed default generated using\n  // the ExpanderComponent and PivotValueComponent at run-time in methods.js\n  PaginationComponent: Pagination,\n  PreviousComponent: undefined,\n  NextComponent: undefined,\n  LoadingComponent: ({\n    className, loading, loadingText, ...rest\n  }) => (\n    <div className={classnames('-loading', { '-active': loading }, className)} {...rest}>\n      <div className=\"-loading-inner\">{loadingText}</div>\n    </div>\n  ),\n  NoDataComponent: _.makeTemplateComponent('rt-noData', 'NoData'),\n  ResizerComponent: _.makeTemplateComponent('rt-resizer', 'Resizer'),\n  PadRowComponent: () => <span>&nbsp;</span>,\n}\n"]} \ No newline at end of file diff --git a/lib/hoc/foldableTable/index.js b/lib/hoc/foldableTable/index.js new file mode 100644 index 0000000000..2687cfa2e3 --- /dev/null +++ b/lib/hoc/foldableTable/index.js @@ -0,0 +1,307 @@ +'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 _left = require('./left.svg'); + +var _left2 = _interopRequireDefault(_left); + +var _right = require('./right.svg'); + +var _right2 = _interopRequireDefault(_right); + +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 _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; } + +var defaultFoldIconComponent = function defaultFoldIconComponent(_ref) { + var collapsed = _ref.collapsed; + + var style = { width: 25 }; + + if (collapsed) return _react2.default.createElement('img', { src: _right2.default, style: style, alt: 'right' }); + return _react2.default.createElement('img', { src: _left2.default, style: style, alt: 'left' }); +}; + +var defaultFoldButtonComponent = function defaultFoldButtonComponent(_ref2) { + var header = _ref2.header, + collapsed = _ref2.collapsed, + icon = _ref2.icon, + onClick = _ref2.onClick; + + var style = { + marginLeft: "0px", + marginTop: "-5px", + marginBottom: "-8px", + float: "left", + cursor: "pointer" + }; + + return _react2.default.createElement( + 'div', + null, + _react2.default.createElement( + 'div', + { style: style, onClick: onClick }, + icon + ), + !collapsed && _react2.default.createElement( + 'div', + null, + header + ) + ); +}; + +exports.default = function (ReactTable) { + + var wrapper = function (_React$Component) { + _inherits(RTFoldableTable, _React$Component); + + function RTFoldableTable(props, context) { + _classCallCheck(this, RTFoldableTable); + + var _this = _possibleConstructorReturn(this, (RTFoldableTable.__proto__ || Object.getPrototypeOf(RTFoldableTable)).call(this, props, context)); + + _this.onResizedChange = function (resized) { + var onResizedChange = _this.props.onResizedChange; + + if (onResizedChange) onResizedChange(resized);else _this.setState(function (p) { + return { resized: resized }; + }); + }; + + _this.removeResized = function (column) { + var id = column.id; + + if (!id) return; + + var resized = _this.state.resized; + + if (!resized) return; + + var rs = resized.find(function (r) { + return r.id === id; + }); + if (!rs) return; + + var newResized = resized.filter(function (r) { + return r !== rs; + }); + _this.onResizedChange(newResized); + }; + + _this.getWrappedInstance = function () { + if (!_this.wrappedInstance) console.warn('RTFoldableTable - No wrapped instance'); + if (_this.wrappedInstance.getWrappedInstance) return _this.wrappedInstance.getWrappedInstance();else return _this.wrappedInstance; + }; + + _this.getCopiedKey = function (key) { + var foldableOriginalKey = _this.props.foldableOriginalKey; + + return '' + foldableOriginalKey + key; + }; + + _this.copyOriginals = function (column) { + var FoldedColumn = _this.props.FoldedColumn; + + //Stop copy if the column already copied + + if (column.original_Header) return; + + Object.keys(FoldedColumn).forEach(function (k) { + var copiedKey = _this.getCopiedKey(k); + + if (k === "Cell") column[copiedKey] = column[k] ? column[k] : function (c) { + return c.value; + };else column[copiedKey] = column[k]; + }); + + //Copy sub Columns + if (column.columns && !column.original_Columns) column.original_Columns = column.columns; + + //Copy Header + if (!column.original_Header) column.original_Header = column.Header; + }; + + _this.restoreToOriginal = function (column) { + var FoldedColumn = _this.props.FoldedColumn; + + + Object.keys(FoldedColumn).forEach(function (k) { + //ignore header as handling by foldableHeaderRender + if (k === "Header") return; + + var copiedKey = _this.getCopiedKey(k); + column[k] = column[copiedKey]; + }); + + if (column.columns && column.original_Columns) column.columns = column.original_Columns; + }; + + _this.getState = function () { + return _this.props.onFoldChange ? _this.props.folded : _this.state.folded; + }; + + _this.isFolded = function (col) { + var folded = _this.getState(); + return folded[col.id] === true; + }; + + _this.foldingHandler = function (col) { + if (!col || !col.id) return; + + var onFoldChange = _this.props.onFoldChange; + + var folded = _this.getState(); + var id = col.id; + + + var newFold = Object.assign({}, folded); + newFold[id] = !newFold[id]; + + //Remove the Resized if have + _this.removeResized(col); + + if (onFoldChange) onFoldChange(newFold);else _this.setState(function (previous) { + return { folded: newFold }; + }); + }; + + _this.foldableHeaderRender = function (cell) { + var _this$props = _this.props, + FoldButtonComponent = _this$props.FoldButtonComponent, + FoldIconComponent = _this$props.FoldIconComponent; + var column = cell.column; + + var collapsed = _this.isFolded(column); + var icon = _react2.default.createElement(FoldIconComponent, { collapsed: collapsed }); + var onClick = function onClick() { + return _this.foldingHandler(column); + }; + + return _react2.default.createElement(FoldButtonComponent, { header: column.original_Header, collapsed: collapsed, icon: icon, onClick: onClick }); + }; + + _this.applyFoldableForColumn = function (column) { + var collapsed = _this.isFolded(column); + var FoldedColumn = _this.props.FoldedColumn; + + //Handle Column Header + + if (column.columns) { + if (collapsed) { + column.columns = [FoldedColumn]; + column.width = FoldedColumn.width; + column.style = FoldedColumn.style; + } else _this.restoreToOriginal(column); + } + //Handle Normal Column. + else if (collapsed) column = Object.assign(column, FoldedColumn);else { + _this.restoreToOriginal(column); + } + }; + + _this.applyFoldableForColumns = function (columns) { + return columns.map(function (col, index) { + if (!col.foldable) return col; + + //If col don't have id then generate id based on index + if (!col.id) col.id = 'col_' + index; + + _this.copyOriginals(col); + //Replace current header with internal header render. + col.Header = function (c) { + return _this.foldableHeaderRender(c); + }; + //apply foldable + _this.applyFoldableForColumn(col); + + //return the new column out + return col; + }); + }; + + _this.state = { + folded: props.onFoldChange ? undefined : {}, + resized: props.resized || [] + }; + return _this; + } + + _createClass(RTFoldableTable, [{ + key: 'componentWillReceiveProps', + value: function componentWillReceiveProps(newProps) { + if (this.state.resized !== newProps.resized) this.setState(function (p) { + return { resized: newProps.resized }; + }); + } + + // this is so we can expose the underlying ReactTable. + + }, { + key: 'render', + value: function render() { + var _this2 = this; + + var _props = this.props, + originalCols = _props.columns, + FoldButtonComponent = _props.FoldButtonComponent, + FoldIconComponent = _props.FoldIconComponent, + FoldedColumn = _props.FoldedColumn, + rest = _objectWithoutProperties(_props, ['columns', 'FoldButtonComponent', 'FoldIconComponent', 'FoldedColumn']); + + var columns = this.applyFoldableForColumns([].concat(_toConsumableArray(originalCols))); + + var extra = { + columns: columns, + onResizedChange: this.onResizedChange, + resized: this.state.resized + }; + + return _react2.default.createElement(ReactTable, _extends({}, rest, extra, { ref: function ref(r) { + return _this2.wrappedInstance = r; + } })); + } + }]); + + return RTFoldableTable; + }(_react2.default.Component); + + wrapper.displayName = 'RTFoldableTable'; + wrapper.defaultProps = { + FoldIconComponent: defaultFoldIconComponent, + FoldButtonComponent: defaultFoldButtonComponent, + foldableOriginalKey: 'original_', + FoldedColumn: { + Cell: function Cell(c) { + return ''; + }, + width: 30, + sortable: false, + resizable: false, + filterable: false + } + }; + + return wrapper; +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/hoc/foldableTable/index.js"],"names":["defaultFoldIconComponent","collapsed","style","width","right","left","defaultFoldButtonComponent","header","icon","onClick","marginLeft","marginTop","marginBottom","float","cursor","ReactTable","wrapper","props","context","onResizedChange","resized","setState","removeResized","id","column","state","rs","find","r","newResized","filter","getWrappedInstance","wrappedInstance","console","warn","getCopiedKey","foldableOriginalKey","key","copyOriginals","FoldedColumn","original_Header","Object","keys","forEach","copiedKey","k","c","value","columns","original_Columns","Header","restoreToOriginal","getState","onFoldChange","folded","isFolded","col","foldingHandler","newFold","assign","foldableHeaderRender","cell","FoldButtonComponent","FoldIconComponent","React","createElement","applyFoldableForColumn","applyFoldableForColumns","map","index","foldable","undefined","newProps","originalCols","rest","extra","Component","displayName","defaultProps","Cell","sortable","resizable","filterable"],"mappings":"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","file":"index.js","sourcesContent":["import React from 'react';\nimport left from './left.svg';\nimport right from './right.svg';\n\nconst defaultFoldIconComponent = ({ collapsed }) => {\n    const style = { width: 25 };\n\n    if (collapsed)\n        return <img src={right} style={style} alt=\"right\" />\n    return <img src={left} style={style} alt=\"left\" />\n}\n\nconst defaultFoldButtonComponent = ({ header, collapsed, icon, onClick }) => {\n    const style = {\n        marginLeft: \"0px\",\n        marginTop: \"-5px\",\n        marginBottom: \"-8px\",\n        float: \"left\",\n        cursor: \"pointer\"\n    };\n\n    return (<div>\n        <div style={style} onClick={onClick}>\n            {icon}\n        </div>\n        {!collapsed && <div>{header}</div>}\n    </div>);\n}\n\nexport default (ReactTable) => {\n\n    const wrapper = class RTFoldableTable extends React.Component {\n        constructor(props, context) {\n            super(props, context);\n\n            this.state = {\n                folded: props.onFoldChange ? undefined : {},\n                resized: props.resized || []\n            };\n        }\n\n        componentWillReceiveProps(newProps) {\n            if (this.state.resized !== newProps.resized)\n                this.setState(p => { return { resized: newProps.resized } });\n        }\n\n        onResizedChange = resized => {\n            const { onResizedChange } = this.props;\n            if (onResizedChange)\n                onResizedChange(resized);\n            else this.setState(p => { return { resized } });\n        }\n\n        removeResized = column => {\n            const { id } = column;\n            if (!id) return;\n\n            const { resized } = this.state;\n            if (!resized) return;\n\n            const rs = resized.find(r => r.id === id);\n            if (!rs) return;\n\n            const newResized = resized.filter(r => r !== rs);\n            this.onResizedChange(newResized);\n        }\n\n        // this is so we can expose the underlying ReactTable.\n        getWrappedInstance = () => {\n            if (!this.wrappedInstance) console.warn('RTFoldableTable - No wrapped instance');\n            if (this.wrappedInstance.getWrappedInstance) return this.wrappedInstance.getWrappedInstance();\n            else return this.wrappedInstance\n        }\n\n        getCopiedKey = key => {\n            const { foldableOriginalKey } = this.props;\n            return `${foldableOriginalKey}${key}`;\n        }\n\n        copyOriginals = column => {\n            const { FoldedColumn } = this.props;\n\n            //Stop copy if the column already copied\n            if (column.original_Header) return;\n\n            Object.keys(FoldedColumn).forEach(k => {\n                const copiedKey = this.getCopiedKey(k);\n\n                if (k === \"Cell\")\n                    column[copiedKey] = column[k] ? column[k] : c => c.value;\n                else column[copiedKey] = column[k];\n            });\n\n            //Copy sub Columns\n            if (column.columns && !column.original_Columns)\n                column.original_Columns = column.columns;\n\n            //Copy Header\n            if (!column.original_Header)\n                column.original_Header = column.Header;\n        }\n\n        restoreToOriginal = column => {\n            const { FoldedColumn } = this.props;\n\n            Object.keys(FoldedColumn).forEach(k => {\n                //ignore header as handling by foldableHeaderRender\n                if (k === \"Header\") return;\n\n                const copiedKey = this.getCopiedKey(k);\n                column[k] = column[copiedKey];\n            });\n\n            if (column.columns && column.original_Columns)\n                column.columns = column.original_Columns;\n        }\n\n        getState = () => this.props.onFoldChange ? this.props.folded : this.state.folded;\n\n        isFolded = col => {\n            const folded = this.getState();\n            return folded[col.id] === true;\n        }\n\n        foldingHandler = col => {\n            if (!col || !col.id) return;\n\n            const { onFoldChange } = this.props;\n            const folded = this.getState();\n            const { id } = col;\n\n            let newFold = Object.assign({}, folded);\n            newFold[id] = !newFold[id];\n\n            //Remove the Resized if have\n            this.removeResized(col);\n\n            if (onFoldChange)\n                onFoldChange(newFold);\n            else this.setState(previous => { return { folded: newFold }; });\n        }\n\n        foldableHeaderRender = (cell) => {\n            const { FoldButtonComponent, FoldIconComponent } = this.props;\n            const { column } = cell;\n            const collapsed = this.isFolded(column);\n            const icon = React.createElement(FoldIconComponent, { collapsed });\n            const onClick = () => this.foldingHandler(column);\n\n            return React.createElement(FoldButtonComponent, { header: column.original_Header, collapsed, icon, onClick });\n        }\n\n        applyFoldableForColumn = column => {\n            const collapsed = this.isFolded(column);\n            const { FoldedColumn } = this.props;\n\n            //Handle Column Header\n            if (column.columns) {\n                if (collapsed) {\n                    column.columns = [FoldedColumn];\n                    column.width = FoldedColumn.width;\n                    column.style = FoldedColumn.style;\n                }\n                else this.restoreToOriginal(column);\n            }\n            //Handle Normal Column.\n            else if (collapsed)\n                column = Object.assign(column, FoldedColumn);\n            else {\n                this.restoreToOriginal(column);\n            }\n        }\n\n        applyFoldableForColumns = columns => {\n            return columns.map((col, index) => {\n                if (!col.foldable) return col;\n\n                //If col don't have id then generate id based on index\n                if (!col.id)\n                    col.id = `col_${index}`;\n\n                this.copyOriginals(col);\n                //Replace current header with internal header render.\n                col.Header = c => this.foldableHeaderRender(c);\n                //apply foldable\n                this.applyFoldableForColumn(col);\n\n                //return the new column out\n                return col;\n            });\n        }\n\n        render() {\n            const { columns: originalCols, FoldButtonComponent, FoldIconComponent, FoldedColumn, ...rest } = this.props;\n            const columns = this.applyFoldableForColumns([...originalCols]);\n\n            const extra = {\n                columns,\n                onResizedChange: this.onResizedChange,\n                resized: this.state.resized\n            };\n\n            return (\n                <ReactTable {...rest} {...extra} ref={r => this.wrappedInstance = r} />\n            )\n        }\n    }\n\n    wrapper.displayName = 'RTFoldableTable';\n    wrapper.defaultProps =\n        {\n            FoldIconComponent: defaultFoldIconComponent,\n            FoldButtonComponent: defaultFoldButtonComponent,\n            foldableOriginalKey: 'original_',\n            FoldedColumn: {\n                Cell: c => '',\n                width: 30,\n                sortable: false,\n                resizable: false,\n                filterable: false,\n            }\n        }\n\n    return wrapper;\n}"]} \ No newline at end of file diff --git a/lib/hoc/selectTable/index.js b/lib/hoc/selectTable/index.js new file mode 100644 index 0000000000..3610ac4915 --- /dev/null +++ b/lib/hoc/selectTable/index.js @@ -0,0 +1,165 @@ +'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); + +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 _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-disable */ + +var defaultSelectInputComponent = function defaultSelectInputComponent(props) { + return _react2.default.createElement('input', { + type: props.selectType || 'checkbox', + checked: props.checked, + onClick: function onClick(e) { + var shiftKey = e.shiftKey; + + e.stopPropagation(); + props.onClick(props.id, shiftKey, props.row); + }, + onChange: function onChange() {} + }); +}; + +exports.default = function (Component) { + var wrapper = function (_React$Component) { + _inherits(RTSelectTable, _React$Component); + + function RTSelectTable(props) { + _classCallCheck(this, RTSelectTable); + + return _possibleConstructorReturn(this, (RTSelectTable.__proto__ || Object.getPrototypeOf(RTSelectTable)).call(this, props)); + } + + _createClass(RTSelectTable, [{ + key: 'rowSelector', + value: function rowSelector(row) { + if (!row || !row.hasOwnProperty(this.props.keyField)) return null; + var _props = this.props, + toggleSelection = _props.toggleSelection, + selectType = _props.selectType, + keyField = _props.keyField; + + var checked = this.props.isSelected(row[this.props.keyField]); + var inputProps = { + checked: checked, + onClick: toggleSelection, + selectType: selectType, + id: row[keyField], + row: row + }; + return _react2.default.createElement(this.props.SelectInputComponent, inputProps); + } + }, { + key: 'headSelector', + value: function headSelector(row) { + var selectType = this.props.selectType; + + if (selectType === 'radio') return null; + + var _props2 = this.props, + toggleAll = _props2.toggleAll, + checked = _props2.selectAll, + SelectAllInputComponent = _props2.SelectAllInputComponent; + + var inputProps = { + checked: checked, + onClick: toggleAll, + selectType: selectType + }; + + return _react2.default.createElement(SelectAllInputComponent, inputProps); + } + + // this is so we can expose the underlying ReactTable to get at the sortedData for selectAll + + }, { + key: 'getWrappedInstance', + value: function getWrappedInstance() { + if (!this.wrappedInstance) console.warn('RTSelectTable - No wrapped instance'); + if (this.wrappedInstance.getWrappedInstance) return this.wrappedInstance.getWrappedInstance();else return this.wrappedInstance; + } + }, { + key: 'render', + value: function render() { + var _this2 = this; + + var _props3 = this.props, + originalCols = _props3.columns, + isSelected = _props3.isSelected, + toggleSelection = _props3.toggleSelection, + toggleAll = _props3.toggleAll, + keyField = _props3.keyField, + selectAll = _props3.selectAll, + selectType = _props3.selectType, + selectWidth = _props3.selectWidth, + SelectAllInputComponent = _props3.SelectAllInputComponent, + SelectInputComponent = _props3.SelectInputComponent, + rest = _objectWithoutProperties(_props3, ['columns', 'isSelected', 'toggleSelection', 'toggleAll', 'keyField', 'selectAll', 'selectType', 'selectWidth', 'SelectAllInputComponent', 'SelectInputComponent']); + + var select = { + id: '_selector', + accessor: function accessor() { + return 'x'; + }, // this value is not important + Header: this.headSelector.bind(this), + Cell: function Cell(ci) { + return _this2.rowSelector.bind(_this2)(ci.original); + }, + width: selectWidth || 30, + filterable: false, + sortable: false, + resizable: false, + style: { textAlign: 'center' } + }; + var columns = [select].concat(_toConsumableArray(originalCols)); + var extra = { + columns: columns + }; + return _react2.default.createElement(Component, _extends({}, rest, extra, { ref: function ref(r) { + return _this2.wrappedInstance = r; + } })); + } + }]); + + return RTSelectTable; + }(_react2.default.Component); + + wrapper.displayName = 'RTSelectTable'; + wrapper.defaultProps = { + keyField: '_id', + isSelected: function isSelected(key) { + console.log('No isSelected handler provided:', { key: key }); + }, + selectAll: false, + toggleSelection: function toggleSelection(key, shift, row) { + console.log('No toggleSelection handler provided:', { key: key, shift: shift, row: row }); + }, + toggleAll: function toggleAll() { + console.log('No toggleAll handler provided.'); + }, + selectType: 'check', + SelectInputComponent: defaultSelectInputComponent, + SelectAllInputComponent: defaultSelectInputComponent + }; + + return wrapper; +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../src/hoc/selectTable/index.js"],"names":["defaultSelectInputComponent","props","selectType","checked","shiftKey","e","stopPropagation","onClick","id","row","wrapper","hasOwnProperty","keyField","toggleSelection","isSelected","inputProps","React","createElement","SelectInputComponent","toggleAll","selectAll","SelectAllInputComponent","wrappedInstance","console","warn","getWrappedInstance","originalCols","columns","selectWidth","rest","select","accessor","Header","headSelector","bind","Cell","rowSelector","ci","original","width","filterable","sortable","resizable","style","textAlign","extra","r","Component","displayName","defaultProps","log","key","shift"],"mappings":"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","file":"index.js","sourcesContent":["/* eslint-disable */\n\nimport React from 'react'\n\nconst defaultSelectInputComponent = props => {\n  return (\n    <input\n      type={props.selectType || 'checkbox'}\n      checked={props.checked}\n      onClick={e => {\n        const { shiftKey } = e\n        e.stopPropagation()\n        props.onClick(props.id, shiftKey, props.row)\n      }}\n      onChange={() => {}}\n    />\n  )\n}\n\nexport default Component => {\n  const wrapper = class RTSelectTable extends React.Component {\n    constructor(props) {\n      super(props)\n    }\n\n    rowSelector(row) {\n      if (!row || !row.hasOwnProperty(this.props.keyField)) return null\n      const { toggleSelection, selectType, keyField } = this.props\n      const checked = this.props.isSelected(row[this.props.keyField])\n      const inputProps = {\n        checked,\n        onClick: toggleSelection,\n        selectType,\n        id: row[keyField],\n        row,\n      }\n      return React.createElement(this.props.SelectInputComponent, inputProps)\n    }\n\n    headSelector(row) {\n      const { selectType } = this.props\n      if (selectType === 'radio') return null\n\n      const { toggleAll, selectAll: checked, SelectAllInputComponent } = this.props\n      const inputProps = {\n        checked,\n        onClick: toggleAll,\n        selectType,\n      }\n\n      return React.createElement(SelectAllInputComponent, inputProps)\n    }\n\n    // this is so we can expose the underlying ReactTable to get at the sortedData for selectAll\n    getWrappedInstance() {\n      if (!this.wrappedInstance) console.warn('RTSelectTable - No wrapped instance')\n      if (this.wrappedInstance.getWrappedInstance) return this.wrappedInstance.getWrappedInstance()\n      else return this.wrappedInstance\n    }\n\n    render() {\n      const {\n        columns: originalCols,\n        isSelected,\n        toggleSelection,\n        toggleAll,\n        keyField,\n        selectAll,\n        selectType,\n        selectWidth,\n        SelectAllInputComponent,\n        SelectInputComponent,\n        ...rest\n      } = this.props\n      const select = {\n        id: '_selector',\n        accessor: () => 'x', // this value is not important\n        Header: this.headSelector.bind(this),\n        Cell: ci => {\n          return this.rowSelector.bind(this)(ci.original)\n        },\n        width: selectWidth || 30,\n        filterable: false,\n        sortable: false,\n        resizable: false,\n        style: { textAlign: 'center' },\n      }\n      const columns = [select, ...originalCols]\n      const extra = {\n        columns,\n      }\n      return <Component {...rest} {...extra} ref={r => (this.wrappedInstance = r)} />\n    }\n  }\n\n  wrapper.displayName = 'RTSelectTable'\n  wrapper.defaultProps = {\n    keyField: '_id',\n    isSelected: key => {\n      console.log('No isSelected handler provided:', { key })\n    },\n    selectAll: false,\n    toggleSelection: (key, shift, row) => {\n      console.log('No toggleSelection handler provided:', { key, shift, row })\n    },\n    toggleAll: () => {\n      console.log('No toggleAll handler provided.')\n    },\n    selectType: 'check',\n    SelectInputComponent: defaultSelectInputComponent,\n    SelectAllInputComponent: defaultSelectInputComponent,\n  }\n\n  return wrapper\n}\n"]} \ No newline at end of file diff --git a/lib/hoc/treeTable/index.js b/lib/hoc/treeTable/index.js new file mode 100644 index 0000000000..6794e28c3c --- /dev/null +++ b/lib/hoc/treeTable/index.js @@ -0,0 +1,126 @@ +'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); + +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-disable */ + +exports.default = function (Component) { + var _class, _temp, _initialiseProps; + + var wrapper = (_temp = _class = function (_React$Component) { + _inherits(RTTreeTable, _React$Component); + + function RTTreeTable(props) { + _classCallCheck(this, RTTreeTable); + + var _this = _possibleConstructorReturn(this, (RTTreeTable.__proto__ || Object.getPrototypeOf(RTTreeTable)).call(this, props)); + + _initialiseProps.call(_this); + + _this.getWrappedInstance.bind(_this); + _this.TrComponent.bind(_this); + _this.getTrProps.bind(_this); + return _this; + } + + // this is so we can expose the underlying ReactTable to get at the sortedData for selectAll + + + _createClass(RTTreeTable, [{ + key: 'render', + value: function render() { + var _this2 = this; + + var _props = this.props, + columns = _props.columns, + treeTableIndent = _props.treeTableIndent, + rest = _objectWithoutProperties(_props, ['columns', 'treeTableIndent']); + + var TrComponent = this.TrComponent, + getTrProps = this.getTrProps; + + var extra = { + columns: columns.map(function (col) { + var column = col; + if (rest.pivotBy && rest.pivotBy.includes(col.accessor)) { + column = { + accessor: col.accessor, + width: treeTableIndent + 'px', + show: false, + Header: '' + }; + } + return column; + }), + TrComponent: TrComponent, + getTrProps: getTrProps + }; + + return _react2.default.createElement(Component, _extends({}, rest, extra, { ref: function ref(r) { + return _this2.wrappedInstance = r; + } })); + } + }]); + + return RTTreeTable; + }(_react2.default.Component), _initialiseProps = function _initialiseProps() { + var _this3 = this; + + this.getWrappedInstance = function () { + if (!_this3.wrappedInstance) console.warn('RTTreeTable - No wrapped instance'); + if (_this3.wrappedInstance.getWrappedInstance) return _this3.wrappedInstance.getWrappedInstance();else return _this3.wrappedInstance; + }; + + this.TrComponent = function (props) { + var ri = props.ri, + rest = _objectWithoutProperties(props, ['ri']); + + if (ri && ri.groupedByPivot) { + var cell = _extends({}, props.children[ri.level]); + + cell.props.style.flex = 'unset'; + cell.props.style.width = '100%'; + cell.props.style.maxWidth = 'unset'; + cell.props.style.paddingLeft = _this3.props.treeTableIndent * ri.level + 'px'; + // cell.props.style.backgroundColor = '#DDD'; + cell.props.style.borderBottom = '1px solid rgba(128,128,128,0.2)'; + + return _react2.default.createElement( + 'div', + { className: 'rt-tr ' + rest.className, style: rest.style }, + cell + ); + } + return _react2.default.createElement(Component.defaultProps.TrComponent, rest); + }; + + this.getTrProps = function (state, ri, ci, instance) { + return { ri: ri }; + }; + }, _temp); + wrapper.displayName = 'RTTreeTable'; + wrapper.defaultProps = { + treeTableIndent: 10 + }; + + return wrapper; +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/lib/index.js b/lib/index.js new file mode 100644 index 0000000000..57152b9206 --- /dev/null +++ b/lib/index.js @@ -0,0 +1,830 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.ReactTableDefaults = undefined; + +var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); + +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 _classnames = require('classnames'); + +var _classnames2 = _interopRequireDefault(_classnames); + +var _utils = require('./utils'); + +var _utils2 = _interopRequireDefault(_utils); + +var _lifecycle = require('./lifecycle'); + +var _lifecycle2 = _interopRequireDefault(_lifecycle); + +var _methods = require('./methods'); + +var _methods2 = _interopRequireDefault(_methods); + +var _defaultProps = require('./defaultProps'); + +var _defaultProps2 = _interopRequireDefault(_defaultProps); + +var _propTypes = require('./propTypes'); + +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; } +// + + +var ReactTableDefaults = exports.ReactTableDefaults = _defaultProps2.default; + +var ReactTable = function (_Methods) { + _inherits(ReactTable, _Methods); + + function ReactTable(props) { + _classCallCheck(this, ReactTable); + + var _this = _possibleConstructorReturn(this, (ReactTable.__proto__ || Object.getPrototypeOf(ReactTable)).call(this)); + + _this.getResolvedState = _this.getResolvedState.bind(_this); + _this.getDataModel = _this.getDataModel.bind(_this); + _this.getSortedData = _this.getSortedData.bind(_this); + _this.fireFetchData = _this.fireFetchData.bind(_this); + _this.getPropOrState = _this.getPropOrState.bind(_this); + _this.getStateOrProp = _this.getStateOrProp.bind(_this); + _this.filterData = _this.filterData.bind(_this); + _this.sortData = _this.sortData.bind(_this); + _this.getMinRows = _this.getMinRows.bind(_this); + _this.onPageChange = _this.onPageChange.bind(_this); + _this.onPageSizeChange = _this.onPageSizeChange.bind(_this); + _this.sortColumn = _this.sortColumn.bind(_this); + _this.filterColumn = _this.filterColumn.bind(_this); + _this.resizeColumnStart = _this.resizeColumnStart.bind(_this); + _this.resizeColumnEnd = _this.resizeColumnEnd.bind(_this); + _this.resizeColumnMoving = _this.resizeColumnMoving.bind(_this); + + _this.state = { + page: props.defaultPage, + pageSize: props.defaultPageSize, + sorted: props.defaultSorted, + expanded: props.defaultExpanded, + filtered: props.defaultFiltered, + resized: props.defaultResized, + currentlyResizing: false, + skipNextSort: false + }; + return _this; + } + + _createClass(ReactTable, [{ + key: 'render', + value: function render() { + var _this2 = this; + + var resolvedState = this.getResolvedState(); + var children = resolvedState.children, + className = resolvedState.className, + style = resolvedState.style, + getProps = resolvedState.getProps, + getTableProps = resolvedState.getTableProps, + getTheadGroupProps = resolvedState.getTheadGroupProps, + getTheadGroupTrProps = resolvedState.getTheadGroupTrProps, + getTheadGroupThProps = resolvedState.getTheadGroupThProps, + getTheadProps = resolvedState.getTheadProps, + getTheadTrProps = resolvedState.getTheadTrProps, + getTheadThProps = resolvedState.getTheadThProps, + getTheadFilterProps = resolvedState.getTheadFilterProps, + getTheadFilterTrProps = resolvedState.getTheadFilterTrProps, + getTheadFilterThProps = resolvedState.getTheadFilterThProps, + getTbodyProps = resolvedState.getTbodyProps, + getTrGroupProps = resolvedState.getTrGroupProps, + getTrProps = resolvedState.getTrProps, + getTdProps = resolvedState.getTdProps, + getTfootProps = resolvedState.getTfootProps, + getTfootTrProps = resolvedState.getTfootTrProps, + getTfootTdProps = resolvedState.getTfootTdProps, + getPaginationProps = resolvedState.getPaginationProps, + getLoadingProps = resolvedState.getLoadingProps, + getNoDataProps = resolvedState.getNoDataProps, + getResizerProps = resolvedState.getResizerProps, + showPagination = resolvedState.showPagination, + showPaginationTop = resolvedState.showPaginationTop, + showPaginationBottom = resolvedState.showPaginationBottom, + manual = resolvedState.manual, + loadingText = resolvedState.loadingText, + noDataText = resolvedState.noDataText, + sortable = resolvedState.sortable, + multiSort = resolvedState.multiSort, + resizable = resolvedState.resizable, + filterable = resolvedState.filterable, + pivotIDKey = resolvedState.pivotIDKey, + pivotValKey = resolvedState.pivotValKey, + pivotBy = resolvedState.pivotBy, + subRowsKey = resolvedState.subRowsKey, + aggregatedKey = resolvedState.aggregatedKey, + originalKey = resolvedState.originalKey, + indexKey = resolvedState.indexKey, + groupedByPivotKey = resolvedState.groupedByPivotKey, + loading = resolvedState.loading, + pageSize = resolvedState.pageSize, + page = resolvedState.page, + sorted = resolvedState.sorted, + filtered = resolvedState.filtered, + resized = resolvedState.resized, + expanded = resolvedState.expanded, + pages = resolvedState.pages, + onExpandedChange = resolvedState.onExpandedChange, + TableComponent = resolvedState.TableComponent, + TheadComponent = resolvedState.TheadComponent, + TbodyComponent = resolvedState.TbodyComponent, + TrGroupComponent = resolvedState.TrGroupComponent, + TrComponent = resolvedState.TrComponent, + ThComponent = resolvedState.ThComponent, + TdComponent = resolvedState.TdComponent, + TfootComponent = resolvedState.TfootComponent, + PaginationComponent = resolvedState.PaginationComponent, + LoadingComponent = resolvedState.LoadingComponent, + SubComponent = resolvedState.SubComponent, + NoDataComponent = resolvedState.NoDataComponent, + ResizerComponent = resolvedState.ResizerComponent, + ExpanderComponent = resolvedState.ExpanderComponent, + PivotValueComponent = resolvedState.PivotValueComponent, + PivotComponent = resolvedState.PivotComponent, + AggregatedComponent = resolvedState.AggregatedComponent, + FilterComponent = resolvedState.FilterComponent, + PadRowComponent = resolvedState.PadRowComponent, + resolvedData = resolvedState.resolvedData, + allVisibleColumns = resolvedState.allVisibleColumns, + headerGroups = resolvedState.headerGroups, + hasHeaderGroups = resolvedState.hasHeaderGroups, + sortedData = resolvedState.sortedData, + currentlyResizing = resolvedState.currentlyResizing; + + // Pagination + + var startRow = pageSize * page; + var endRow = startRow + pageSize; + var pageRows = manual ? resolvedData : sortedData.slice(startRow, endRow); + var minRows = this.getMinRows(); + var padRows = _utils2.default.range(Math.max(minRows - pageRows.length, 0)); + + var hasColumnFooter = allVisibleColumns.some(function (d) { + return d.Footer; + }); + var hasFilters = filterable || allVisibleColumns.some(function (d) { + return d.filterable; + }); + + var recurseRowsViewIndex = function recurseRowsViewIndex(rows) { + var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + var index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1; + return [rows.map(function (row, i) { + index += 1; + var rowWithViewIndex = _extends({}, row, { + _viewIndex: index + }); + var newPath = path.concat([i]); + if (rowWithViewIndex[subRowsKey] && _utils2.default.get(expanded, newPath)) { + var _recurseRowsViewIndex = recurseRowsViewIndex(rowWithViewIndex[subRowsKey], newPath, index); + + var _recurseRowsViewIndex2 = _slicedToArray(_recurseRowsViewIndex, 2); + + rowWithViewIndex[subRowsKey] = _recurseRowsViewIndex2[0]; + index = _recurseRowsViewIndex2[1]; + } + return rowWithViewIndex; + }), index]; + }; + + var _recurseRowsViewIndex3 = recurseRowsViewIndex(pageRows); + + var _recurseRowsViewIndex4 = _slicedToArray(_recurseRowsViewIndex3, 1); + + pageRows = _recurseRowsViewIndex4[0]; + + + var canPrevious = page > 0; + var canNext = page + 1 < pages; + + var rowMinWidth = _utils2.default.sum(allVisibleColumns.map(function (d) { + var resizedColumn = resized.find(function (x) { + return x.id === d.id; + }) || {}; + return _utils2.default.getFirstDefined(resizedColumn.value, d.width, d.minWidth); + })); + + var rowIndex = -1; + + var finalState = _extends({}, resolvedState, { + startRow: startRow, + endRow: endRow, + pageRows: pageRows, + minRows: minRows, + padRows: padRows, + hasColumnFooter: hasColumnFooter, + canPrevious: canPrevious, + canNext: canNext, + rowMinWidth: rowMinWidth + }); + + var rootProps = _utils2.default.splitProps(getProps(finalState, undefined, undefined, this)); + var tableProps = _utils2.default.splitProps(getTableProps(finalState, undefined, undefined, this)); + var tBodyProps = _utils2.default.splitProps(getTbodyProps(finalState, undefined, undefined, this)); + var loadingProps = getLoadingProps(finalState, undefined, undefined, this); + var noDataProps = getNoDataProps(finalState, undefined, undefined, this); + + // Visual Components + + var makeHeaderGroup = function makeHeaderGroup(column, i) { + var resizedValue = function resizedValue(col) { + return (resized.find(function (x) { + return x.id === col.id; + }) || {}).value; + }; + var flex = _utils2.default.sum(column.columns.map(function (col) { + return col.width || resizedValue(col) ? 0 : col.minWidth; + })); + var width = _utils2.default.sum(column.columns.map(function (col) { + return _utils2.default.getFirstDefined(resizedValue(col), col.width, col.minWidth); + })); + var maxWidth = _utils2.default.sum(column.columns.map(function (col) { + return _utils2.default.getFirstDefined(resizedValue(col), col.width, col.maxWidth); + })); + + var theadGroupThProps = _utils2.default.splitProps(getTheadGroupThProps(finalState, undefined, column, _this2)); + var columnHeaderProps = _utils2.default.splitProps(column.getHeaderProps(finalState, undefined, column, _this2)); + + var classes = [column.headerClassName, theadGroupThProps.className, columnHeaderProps.className]; + + var styles = _extends({}, column.headerStyle, theadGroupThProps.style, columnHeaderProps.style); + + var rest = _extends({}, theadGroupThProps.rest, columnHeaderProps.rest); + + var flexStyles = { + flex: flex + ' 0 auto', + width: _utils2.default.asPx(width), + maxWidth: _utils2.default.asPx(maxWidth) + }; + + return _react2.default.createElement( + ThComponent, + _extends({ + key: i + '-' + column.id, + className: (0, _classnames2.default)(classes), + style: _extends({}, styles, flexStyles) + }, rest), + _utils2.default.normalizeComponent(column.Header, { + data: sortedData, + column: column + }) + ); + }; + + var makeHeaderGroups = function makeHeaderGroups() { + var theadGroupProps = _utils2.default.splitProps(getTheadGroupProps(finalState, undefined, undefined, _this2)); + var theadGroupTrProps = _utils2.default.splitProps(getTheadGroupTrProps(finalState, undefined, undefined, _this2)); + return _react2.default.createElement( + TheadComponent, + _extends({ + className: (0, _classnames2.default)('-headerGroups', theadGroupProps.className), + style: _extends({}, theadGroupProps.style, { + minWidth: rowMinWidth + 'px' + }) + }, theadGroupProps.rest), + _react2.default.createElement( + TrComponent, + _extends({ + className: theadGroupTrProps.className, + style: theadGroupTrProps.style + }, theadGroupTrProps.rest), + headerGroups.map(makeHeaderGroup) + ) + ); + }; + + var makeHeader = function makeHeader(column, i) { + var resizedCol = resized.find(function (x) { + return x.id === column.id; + }) || {}; + var sort = sorted.find(function (d) { + return d.id === column.id; + }); + var show = typeof column.show === 'function' ? column.show() : column.show; + var width = _utils2.default.getFirstDefined(resizedCol.value, column.width, column.minWidth); + var maxWidth = _utils2.default.getFirstDefined(resizedCol.value, column.width, column.maxWidth); + var theadThProps = _utils2.default.splitProps(getTheadThProps(finalState, undefined, column, _this2)); + var columnHeaderProps = _utils2.default.splitProps(column.getHeaderProps(finalState, undefined, column, _this2)); + + var classes = [column.headerClassName, theadThProps.className, columnHeaderProps.className]; + + var styles = _extends({}, column.headerStyle, theadThProps.style, columnHeaderProps.style); + + var rest = _extends({}, theadThProps.rest, columnHeaderProps.rest); + + var isResizable = _utils2.default.getFirstDefined(column.resizable, resizable, false); + var resizer = isResizable ? _react2.default.createElement(ResizerComponent, _extends({ + onMouseDown: function onMouseDown(e) { + return _this2.resizeColumnStart(e, column, false); + }, + onTouchStart: function onTouchStart(e) { + return _this2.resizeColumnStart(e, column, true); + } + }, getResizerProps('finalState', undefined, column, _this2))) : null; + + var isSortable = _utils2.default.getFirstDefined(column.sortable, sortable, false); + + return _react2.default.createElement( + ThComponent, + _extends({ + key: i + '-' + column.id, + className: (0, _classnames2.default)(classes, isResizable && 'rt-resizable-header', sort ? sort.desc ? '-sort-desc' : '-sort-asc' : '', isSortable && '-cursor-pointer', !show && '-hidden', pivotBy && pivotBy.slice(0, -1).includes(column.id) && 'rt-header-pivot'), + style: _extends({}, styles, { + flex: width + ' 0 auto', + width: _utils2.default.asPx(width), + maxWidth: _utils2.default.asPx(maxWidth) + }), + toggleSort: function toggleSort(e) { + if (isSortable) _this2.sortColumn(column, multiSort ? e.shiftKey : false); + } + }, rest), + _react2.default.createElement( + 'div', + { className: (0, _classnames2.default)(isResizable && 'rt-resizable-header-content') }, + _utils2.default.normalizeComponent(column.Header, { + data: sortedData, + column: column + }) + ), + resizer + ); + }; + + var makeHeaders = function makeHeaders() { + var theadProps = _utils2.default.splitProps(getTheadProps(finalState, undefined, undefined, _this2)); + var theadTrProps = _utils2.default.splitProps(getTheadTrProps(finalState, undefined, undefined, _this2)); + return _react2.default.createElement( + TheadComponent, + _extends({ + className: (0, _classnames2.default)('-header', theadProps.className), + style: _extends({}, theadProps.style, { + minWidth: rowMinWidth + 'px' + }) + }, theadProps.rest), + _react2.default.createElement( + TrComponent, + _extends({ + className: theadTrProps.className, + style: theadTrProps.style + }, theadTrProps.rest), + allVisibleColumns.map(makeHeader) + ) + ); + }; + + var makeFilter = function makeFilter(column, i) { + var resizedCol = resized.find(function (x) { + return x.id === column.id; + }) || {}; + var width = _utils2.default.getFirstDefined(resizedCol.value, column.width, column.minWidth); + var maxWidth = _utils2.default.getFirstDefined(resizedCol.value, column.width, column.maxWidth); + var theadFilterThProps = _utils2.default.splitProps(getTheadFilterThProps(finalState, undefined, column, _this2)); + var columnHeaderProps = _utils2.default.splitProps(column.getHeaderProps(finalState, undefined, column, _this2)); + + var classes = [column.headerClassName, theadFilterThProps.className, columnHeaderProps.className]; + + var styles = _extends({}, column.headerStyle, theadFilterThProps.style, columnHeaderProps.style); + + var rest = _extends({}, theadFilterThProps.rest, columnHeaderProps.rest); + + var filter = filtered.find(function (filter) { + return filter.id === column.id; + }); + + var ResolvedFilterComponent = column.Filter || FilterComponent; + + var isFilterable = _utils2.default.getFirstDefined(column.filterable, filterable, false); + + return _react2.default.createElement( + ThComponent, + _extends({ + key: i + '-' + column.id, + className: (0, _classnames2.default)(classes), + style: _extends({}, styles, { + flex: width + ' 0 auto', + width: _utils2.default.asPx(width), + maxWidth: _utils2.default.asPx(maxWidth) + }) + }, rest), + isFilterable ? _utils2.default.normalizeComponent(ResolvedFilterComponent, { + column: column, + filter: filter, + onChange: function onChange(value) { + return _this2.filterColumn(column, value); + } + }, _defaultProps2.default.column.Filter) : null + ); + }; + + var makeFilters = function makeFilters() { + var theadFilterProps = _utils2.default.splitProps(getTheadFilterProps(finalState, undefined, undefined, _this2)); + var theadFilterTrProps = _utils2.default.splitProps(getTheadFilterTrProps(finalState, undefined, undefined, _this2)); + return _react2.default.createElement( + TheadComponent, + _extends({ + className: (0, _classnames2.default)('-filters', theadFilterProps.className), + style: _extends({}, theadFilterProps.style, { + minWidth: rowMinWidth + 'px' + }) + }, theadFilterProps.rest), + _react2.default.createElement( + TrComponent, + _extends({ + className: theadFilterTrProps.className, + style: theadFilterTrProps.style + }, theadFilterTrProps.rest), + allVisibleColumns.map(makeFilter) + ) + ); + }; + + var makePageRow = function makePageRow(row, i) { + var path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : []; + + var rowInfo = { + original: row[originalKey], + row: row, + index: row[indexKey], + viewIndex: rowIndex += 1, + pageSize: pageSize, + page: page, + level: path.length, + nestingPath: path.concat([i]), + aggregated: row[aggregatedKey], + groupedByPivot: row[groupedByPivotKey], + subRows: row[subRowsKey] + }; + var isExpanded = _utils2.default.get(expanded, rowInfo.nestingPath); + var trGroupProps = getTrGroupProps(finalState, rowInfo, undefined, _this2); + var trProps = _utils2.default.splitProps(getTrProps(finalState, rowInfo, undefined, _this2)); + return _react2.default.createElement( + TrGroupComponent, + _extends({ key: rowInfo.nestingPath.join('_') }, trGroupProps), + _react2.default.createElement( + TrComponent, + _extends({ + className: (0, _classnames2.default)(trProps.className, row._viewIndex % 2 ? '-even' : '-odd'), + style: trProps.style + }, trProps.rest), + allVisibleColumns.map(function (column, i2) { + var resizedCol = resized.find(function (x) { + return x.id === column.id; + }) || {}; + var show = typeof column.show === 'function' ? column.show() : column.show; + var width = _utils2.default.getFirstDefined(resizedCol.value, column.width, column.minWidth); + var maxWidth = _utils2.default.getFirstDefined(resizedCol.value, column.width, column.maxWidth); + var tdProps = _utils2.default.splitProps(getTdProps(finalState, rowInfo, column, _this2)); + var columnProps = _utils2.default.splitProps(column.getProps(finalState, rowInfo, column, _this2)); + + var classes = [tdProps.className, column.className, columnProps.className]; + + var styles = _extends({}, tdProps.style, column.style, columnProps.style); + + var cellInfo = _extends({}, rowInfo, { + isExpanded: isExpanded, + column: _extends({}, column), + value: rowInfo.row[column.id], + pivoted: column.pivoted, + expander: column.expander, + resized: resized, + show: show, + width: width, + maxWidth: maxWidth, + tdProps: tdProps, + columnProps: columnProps, + classes: classes, + styles: styles + }); + + var value = cellInfo.value; + + var useOnExpanderClick = void 0; + var isBranch = void 0; + var isPreview = void 0; + + var onExpanderClick = function onExpanderClick(e) { + var newExpanded = _utils2.default.clone(expanded); + if (isExpanded) { + newExpanded = _utils2.default.set(newExpanded, cellInfo.nestingPath, false); + } else { + newExpanded = _utils2.default.set(newExpanded, cellInfo.nestingPath, {}); + } + + return _this2.setStateWithData({ + expanded: newExpanded + }, function () { + return onExpandedChange && onExpandedChange(newExpanded, cellInfo.nestingPath, e); + }); + }; + + // Default to a standard cell + var resolvedCell = _utils2.default.normalizeComponent(column.Cell, cellInfo, value); + + // Resolve Renderers + var ResolvedAggregatedComponent = column.Aggregated || (!column.aggregate ? AggregatedComponent : column.Cell); + var ResolvedExpanderComponent = column.Expander || ExpanderComponent; + var ResolvedPivotValueComponent = column.PivotValue || PivotValueComponent; + var DefaultResolvedPivotComponent = PivotComponent || function (props) { + return _react2.default.createElement( + 'div', + null, + _react2.default.createElement(ResolvedExpanderComponent, props), + _react2.default.createElement(ResolvedPivotValueComponent, props) + ); + }; + var ResolvedPivotComponent = column.Pivot || DefaultResolvedPivotComponent; + + // Is this cell expandable? + if (cellInfo.pivoted || cellInfo.expander) { + // Make it expandable by defualt + cellInfo.expandable = true; + useOnExpanderClick = true; + // If pivoted, has no subRows, and does not have a subComponent, + // do not make expandable + if (cellInfo.pivoted && !cellInfo.subRows && !SubComponent) { + cellInfo.expandable = false; + } + } + + if (cellInfo.pivoted) { + // Is this column a branch? + isBranch = rowInfo.row[pivotIDKey] === column.id && cellInfo.subRows; + // Should this column be blank? + isPreview = pivotBy.indexOf(column.id) > pivotBy.indexOf(rowInfo.row[pivotIDKey]) && cellInfo.subRows; + // Pivot Cell Render Override + if (isBranch) { + // isPivot + resolvedCell = _utils2.default.normalizeComponent(ResolvedPivotComponent, _extends({}, cellInfo, { + value: row[pivotValKey] + }), row[pivotValKey]); + } else if (isPreview) { + // Show the pivot preview + resolvedCell = _utils2.default.normalizeComponent(ResolvedAggregatedComponent, cellInfo, value); + } else { + resolvedCell = null; + } + } else if (cellInfo.aggregated) { + resolvedCell = _utils2.default.normalizeComponent(ResolvedAggregatedComponent, cellInfo, value); + } + + if (cellInfo.expander) { + resolvedCell = _utils2.default.normalizeComponent(ResolvedExpanderComponent, cellInfo, row[pivotValKey]); + if (pivotBy) { + if (cellInfo.groupedByPivot) { + resolvedCell = null; + } + if (!cellInfo.subRows && !SubComponent) { + resolvedCell = null; + } + } + } + + var resolvedOnExpanderClick = useOnExpanderClick ? onExpanderClick : function () {}; + + // If there are multiple onClick events, make sure they don't + // override eachother. This should maybe be expanded to handle all + // function attributes + var interactionProps = { + onClick: resolvedOnExpanderClick + }; + + if (tdProps.rest.onClick) { + interactionProps.onClick = function (e) { + tdProps.rest.onClick(e, function () { + return resolvedOnExpanderClick(e); + }); + }; + } + + if (columnProps.rest.onClick) { + interactionProps.onClick = function (e) { + columnProps.rest.onClick(e, function () { + return resolvedOnExpanderClick(e); + }); + }; + } + + // Return the cell + return _react2.default.createElement( + TdComponent + // eslint-disable-next-line react/no-array-index-key + , + _extends({ key: i2 + '-' + column.id, + className: (0, _classnames2.default)(classes, !show && 'hidden', cellInfo.expandable && 'rt-expandable', (isBranch || isPreview) && 'rt-pivot'), + style: _extends({}, styles, { + flex: width + ' 0 auto', + width: _utils2.default.asPx(width), + maxWidth: _utils2.default.asPx(maxWidth) + }) + }, tdProps.rest, columnProps.rest, interactionProps), + resolvedCell + ); + }) + ), + rowInfo.subRows && isExpanded && rowInfo.subRows.map(function (d, i) { + return makePageRow(d, i, rowInfo.nestingPath); + }), + SubComponent && !rowInfo.subRows && isExpanded && SubComponent(rowInfo) + ); + }; + + var makePadColumn = function makePadColumn(column, i) { + var resizedCol = resized.find(function (x) { + return x.id === column.id; + }) || {}; + var show = typeof column.show === 'function' ? column.show() : column.show; + var width = _utils2.default.getFirstDefined(resizedCol.value, column.width, column.minWidth); + var flex = width; + var maxWidth = _utils2.default.getFirstDefined(resizedCol.value, column.width, column.maxWidth); + var tdProps = _utils2.default.splitProps(getTdProps(finalState, undefined, column, _this2)); + var columnProps = _utils2.default.splitProps(column.getProps(finalState, undefined, column, _this2)); + + var classes = [tdProps.className, column.className, columnProps.className]; + + var styles = _extends({}, tdProps.style, column.style, columnProps.style); + + return _react2.default.createElement( + TdComponent, + _extends({ + key: i + '-' + column.id, + className: (0, _classnames2.default)(classes, !show && 'hidden'), + style: _extends({}, styles, { + flex: flex + ' 0 auto', + width: _utils2.default.asPx(width), + maxWidth: _utils2.default.asPx(maxWidth) + }) + }, tdProps.rest), + _utils2.default.normalizeComponent(PadRowComponent) + ); + }; + + var makePadRow = function makePadRow(row, i) { + var trGroupProps = getTrGroupProps(finalState, undefined, undefined, _this2); + var trProps = _utils2.default.splitProps(getTrProps(finalState, undefined, undefined, _this2)); + return _react2.default.createElement( + TrGroupComponent, + _extends({ key: 'pad-' + i }, trGroupProps), + _react2.default.createElement( + TrComponent, + { + className: (0, _classnames2.default)('-padRow', (pageRows.length + i) % 2 ? '-even' : '-odd', trProps.className), + style: trProps.style || {} + }, + allVisibleColumns.map(makePadColumn) + ) + ); + }; + + var makeColumnFooter = function makeColumnFooter(column, i) { + var resizedCol = resized.find(function (x) { + return x.id === column.id; + }) || {}; + var show = typeof column.show === 'function' ? column.show() : column.show; + var width = _utils2.default.getFirstDefined(resizedCol.value, column.width, column.minWidth); + var maxWidth = _utils2.default.getFirstDefined(resizedCol.value, column.width, column.maxWidth); + var tFootTdProps = _utils2.default.splitProps(getTfootTdProps(finalState, undefined, undefined, _this2)); + var columnProps = _utils2.default.splitProps(column.getProps(finalState, undefined, column, _this2)); + var columnFooterProps = _utils2.default.splitProps(column.getFooterProps(finalState, undefined, column, _this2)); + + var classes = [tFootTdProps.className, column.className, columnProps.className, columnFooterProps.className]; + + var styles = _extends({}, tFootTdProps.style, column.style, columnProps.style, columnFooterProps.style); + + return _react2.default.createElement( + TdComponent, + _extends({ + key: i + '-' + column.id, + className: (0, _classnames2.default)(classes, !show && 'hidden'), + style: _extends({}, styles, { + flex: width + ' 0 auto', + width: _utils2.default.asPx(width), + maxWidth: _utils2.default.asPx(maxWidth) + }) + }, columnProps.rest, tFootTdProps.rest, columnFooterProps.rest), + _utils2.default.normalizeComponent(column.Footer, { + data: sortedData, + column: column + }) + ); + }; + + var makeColumnFooters = function makeColumnFooters() { + var tFootProps = getTfootProps(finalState, undefined, undefined, _this2); + var tFootTrProps = _utils2.default.splitProps(getTfootTrProps(finalState, undefined, undefined, _this2)); + return _react2.default.createElement( + TfootComponent, + _extends({ + className: tFootProps.className, + style: _extends({}, tFootProps.style, { + minWidth: rowMinWidth + 'px' + }) + }, tFootProps.rest), + _react2.default.createElement( + TrComponent, + _extends({ + className: (0, _classnames2.default)(tFootTrProps.className), + style: tFootTrProps.style + }, tFootTrProps.rest), + allVisibleColumns.map(makeColumnFooter) + ) + ); + }; + + var makePagination = function makePagination() { + var paginationProps = _utils2.default.splitProps(getPaginationProps(finalState, undefined, undefined, _this2)); + return _react2.default.createElement(PaginationComponent, _extends({}, resolvedState, { + pages: pages, + canPrevious: canPrevious, + canNext: canNext, + onPageChange: _this2.onPageChange, + onPageSizeChange: _this2.onPageSizeChange, + className: paginationProps.className, + style: paginationProps.style + }, paginationProps.rest)); + }; + + var makeTable = function makeTable() { + var pagination = makePagination(); + return _react2.default.createElement( + 'div', + _extends({ + className: (0, _classnames2.default)('ReactTable', className, rootProps.className), + style: _extends({}, style, rootProps.style) + }, rootProps.rest), + showPagination && showPaginationTop ? _react2.default.createElement( + 'div', + { className: 'pagination-top' }, + pagination + ) : null, + _react2.default.createElement( + TableComponent, + _extends({ + className: (0, _classnames2.default)(tableProps.className, currentlyResizing ? 'rt-resizing' : ''), + style: tableProps.style + }, tableProps.rest), + hasHeaderGroups ? makeHeaderGroups() : null, + makeHeaders(), + hasFilters ? makeFilters() : null, + _react2.default.createElement( + TbodyComponent, + _extends({ + className: (0, _classnames2.default)(tBodyProps.className), + style: _extends({}, tBodyProps.style, { + minWidth: rowMinWidth + 'px' + }) + }, tBodyProps.rest), + pageRows.map(function (d, i) { + return makePageRow(d, i); + }), + padRows.map(makePadRow) + ), + hasColumnFooter ? makeColumnFooters() : null + ), + showPagination && showPaginationBottom ? _react2.default.createElement( + 'div', + { className: 'pagination-bottom' }, + pagination + ) : null, + !pageRows.length && _react2.default.createElement( + NoDataComponent, + noDataProps, + _utils2.default.normalizeComponent(noDataText) + ), + _react2.default.createElement(LoadingComponent, _extends({ loading: loading, loadingText: loadingText }, loadingProps)) + ); + }; + + // childProps are optionally passed to a function-as-a-child + return children ? children(finalState, makeTable, this) : makeTable(); + } + }]); + + return ReactTable; +}((0, _methods2.default)((0, _lifecycle2.default)(_react.Component))); + +ReactTable.propTypes = _propTypes2.default; +ReactTable.defaultProps = _defaultProps2.default; +exports.default = ReactTable; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/index.js"],"names":["ReactTableDefaults","defaultProps","ReactTable","props","getResolvedState","bind","getDataModel","getSortedData","fireFetchData","getPropOrState","getStateOrProp","filterData","sortData","getMinRows","onPageChange","onPageSizeChange","sortColumn","filterColumn","resizeColumnStart","resizeColumnEnd","resizeColumnMoving","state","page","defaultPage","pageSize","defaultPageSize","sorted","defaultSorted","expanded","defaultExpanded","filtered","defaultFiltered","resized","defaultResized","currentlyResizing","skipNextSort","resolvedState","children","className","style","getProps","getTableProps","getTheadGroupProps","getTheadGroupTrProps","getTheadGroupThProps","getTheadProps","getTheadTrProps","getTheadThProps","getTheadFilterProps","getTheadFilterTrProps","getTheadFilterThProps","getTbodyProps","getTrGroupProps","getTrProps","getTdProps","getTfootProps","getTfootTrProps","getTfootTdProps","getPaginationProps","getLoadingProps","getNoDataProps","getResizerProps","showPagination","showPaginationTop","showPaginationBottom","manual","loadingText","noDataText","sortable","multiSort","resizable","filterable","pivotIDKey","pivotValKey","pivotBy","subRowsKey","aggregatedKey","originalKey","indexKey","groupedByPivotKey","loading","pages","onExpandedChange","TableComponent","TheadComponent","TbodyComponent","TrGroupComponent","TrComponent","ThComponent","TdComponent","TfootComponent","PaginationComponent","LoadingComponent","SubComponent","NoDataComponent","ResizerComponent","ExpanderComponent","PivotValueComponent","PivotComponent","AggregatedComponent","FilterComponent","PadRowComponent","resolvedData","allVisibleColumns","headerGroups","hasHeaderGroups","sortedData","startRow","endRow","pageRows","slice","minRows","padRows","_","range","Math","max","length","hasColumnFooter","some","d","Footer","hasFilters","recurseRowsViewIndex","rows","path","index","map","row","i","rowWithViewIndex","_viewIndex","newPath","concat","get","canPrevious","canNext","rowMinWidth","sum","resizedColumn","find","x","id","getFirstDefined","value","width","minWidth","rowIndex","finalState","rootProps","splitProps","undefined","tableProps","tBodyProps","loadingProps","noDataProps","makeHeaderGroup","column","resizedValue","col","flex","columns","maxWidth","theadGroupThProps","columnHeaderProps","getHeaderProps","classes","headerClassName","styles","headerStyle","rest","flexStyles","asPx","normalizeComponent","Header","data","makeHeaderGroups","theadGroupProps","theadGroupTrProps","makeHeader","resizedCol","sort","show","theadThProps","isResizable","resizer","e","isSortable","desc","includes","shiftKey","makeHeaders","theadProps","theadTrProps","makeFilter","theadFilterThProps","filter","ResolvedFilterComponent","Filter","isFilterable","onChange","makeFilters","theadFilterProps","theadFilterTrProps","makePageRow","rowInfo","original","viewIndex","level","nestingPath","aggregated","groupedByPivot","subRows","isExpanded","trGroupProps","trProps","join","i2","tdProps","columnProps","cellInfo","pivoted","expander","useOnExpanderClick","isBranch","isPreview","onExpanderClick","newExpanded","clone","set","setStateWithData","resolvedCell","Cell","ResolvedAggregatedComponent","Aggregated","aggregate","ResolvedExpanderComponent","Expander","ResolvedPivotValueComponent","PivotValue","DefaultResolvedPivotComponent","ResolvedPivotComponent","Pivot","expandable","indexOf","resolvedOnExpanderClick","interactionProps","onClick","makePadColumn","makePadRow","makeColumnFooter","tFootTdProps","columnFooterProps","getFooterProps","makeColumnFooters","tFootProps","tFootTrProps","makePagination","paginationProps","makeTable","pagination","Component","propTypes"],"mappings":"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","file":"index.js","sourcesContent":["import React, { Component } from 'react'\nimport classnames from 'classnames'\n//\nimport _ from './utils'\nimport Lifecycle from './lifecycle'\nimport Methods from './methods'\nimport defaultProps from './defaultProps'\nimport propTypes from './propTypes'\n\nexport const ReactTableDefaults = defaultProps\n\nexport default class ReactTable extends Methods(Lifecycle(Component)) {\n  static propTypes = propTypes\n  static defaultProps = defaultProps\n\n  constructor (props) {\n    super()\n\n    this.getResolvedState = this.getResolvedState.bind(this)\n    this.getDataModel = this.getDataModel.bind(this)\n    this.getSortedData = this.getSortedData.bind(this)\n    this.fireFetchData = this.fireFetchData.bind(this)\n    this.getPropOrState = this.getPropOrState.bind(this)\n    this.getStateOrProp = this.getStateOrProp.bind(this)\n    this.filterData = this.filterData.bind(this)\n    this.sortData = this.sortData.bind(this)\n    this.getMinRows = this.getMinRows.bind(this)\n    this.onPageChange = this.onPageChange.bind(this)\n    this.onPageSizeChange = this.onPageSizeChange.bind(this)\n    this.sortColumn = this.sortColumn.bind(this)\n    this.filterColumn = this.filterColumn.bind(this)\n    this.resizeColumnStart = this.resizeColumnStart.bind(this)\n    this.resizeColumnEnd = this.resizeColumnEnd.bind(this)\n    this.resizeColumnMoving = this.resizeColumnMoving.bind(this)\n\n    this.state = {\n      page: props.defaultPage,\n      pageSize: props.defaultPageSize,\n      sorted: props.defaultSorted,\n      expanded: props.defaultExpanded,\n      filtered: props.defaultFiltered,\n      resized: props.defaultResized,\n      currentlyResizing: false,\n      skipNextSort: false,\n    }\n  }\n\n  render () {\n    const resolvedState = this.getResolvedState()\n    const {\n      children,\n      className,\n      style,\n      getProps,\n      getTableProps,\n      getTheadGroupProps,\n      getTheadGroupTrProps,\n      getTheadGroupThProps,\n      getTheadProps,\n      getTheadTrProps,\n      getTheadThProps,\n      getTheadFilterProps,\n      getTheadFilterTrProps,\n      getTheadFilterThProps,\n      getTbodyProps,\n      getTrGroupProps,\n      getTrProps,\n      getTdProps,\n      getTfootProps,\n      getTfootTrProps,\n      getTfootTdProps,\n      getPaginationProps,\n      getLoadingProps,\n      getNoDataProps,\n      getResizerProps,\n      showPagination,\n      showPaginationTop,\n      showPaginationBottom,\n      manual,\n      loadingText,\n      noDataText,\n      sortable,\n      multiSort,\n      resizable,\n      filterable,\n      // Pivoting State\n      pivotIDKey,\n      pivotValKey,\n      pivotBy,\n      subRowsKey,\n      aggregatedKey,\n      originalKey,\n      indexKey,\n      groupedByPivotKey,\n      // State\n      loading,\n      pageSize,\n      page,\n      sorted,\n      filtered,\n      resized,\n      expanded,\n      pages,\n      onExpandedChange,\n      // Components\n      TableComponent,\n      TheadComponent,\n      TbodyComponent,\n      TrGroupComponent,\n      TrComponent,\n      ThComponent,\n      TdComponent,\n      TfootComponent,\n      PaginationComponent,\n      LoadingComponent,\n      SubComponent,\n      NoDataComponent,\n      ResizerComponent,\n      ExpanderComponent,\n      PivotValueComponent,\n      PivotComponent,\n      AggregatedComponent,\n      FilterComponent,\n      PadRowComponent,\n      // Data model\n      resolvedData,\n      allVisibleColumns,\n      headerGroups,\n      hasHeaderGroups,\n      // Sorted Data\n      sortedData,\n      currentlyResizing,\n    } = resolvedState\n\n    // Pagination\n    const startRow = pageSize * page\n    const endRow = startRow + pageSize\n    let pageRows = manual ? resolvedData : sortedData.slice(startRow, endRow)\n    const minRows = this.getMinRows()\n    const padRows = _.range(Math.max(minRows - pageRows.length, 0))\n\n    const hasColumnFooter = allVisibleColumns.some(d => d.Footer)\n    const hasFilters = filterable || allVisibleColumns.some(d => d.filterable)\n\n    const recurseRowsViewIndex = (rows, path = [], index = -1) => [\n      rows.map((row, i) => {\n        index += 1\n        const rowWithViewIndex = {\n          ...row,\n          _viewIndex: index,\n        }\n        const newPath = path.concat([i])\n        if (rowWithViewIndex[subRowsKey] && _.get(expanded, newPath)) {\n          [rowWithViewIndex[subRowsKey], index] = recurseRowsViewIndex(\n            rowWithViewIndex[subRowsKey],\n            newPath,\n            index\n          )\n        }\n        return rowWithViewIndex\n      }),\n      index,\n    ];\n    [pageRows] = recurseRowsViewIndex(pageRows)\n\n    const canPrevious = page > 0\n    const canNext = page + 1 < pages\n\n    const rowMinWidth = _.sum(\n      allVisibleColumns.map(d => {\n        const resizedColumn = resized.find(x => x.id === d.id) || {}\n        return _.getFirstDefined(resizedColumn.value, d.width, d.minWidth)\n      })\n    )\n\n    let rowIndex = -1\n\n    const finalState = {\n      ...resolvedState,\n      startRow,\n      endRow,\n      pageRows,\n      minRows,\n      padRows,\n      hasColumnFooter,\n      canPrevious,\n      canNext,\n      rowMinWidth,\n    }\n\n    const rootProps = _.splitProps(getProps(finalState, undefined, undefined, this))\n    const tableProps = _.splitProps(getTableProps(finalState, undefined, undefined, this))\n    const tBodyProps = _.splitProps(getTbodyProps(finalState, undefined, undefined, this))\n    const loadingProps = getLoadingProps(finalState, undefined, undefined, this)\n    const noDataProps = getNoDataProps(finalState, undefined, undefined, this)\n\n    // Visual Components\n\n    const makeHeaderGroup = (column, i) => {\n      const resizedValue = col => (resized.find(x => x.id === col.id) || {}).value\n      const flex = _.sum(\n        column.columns.map(col => (col.width || resizedValue(col) ? 0 : col.minWidth))\n      )\n      const width = _.sum(\n        column.columns.map(col => _.getFirstDefined(resizedValue(col), col.width, col.minWidth))\n      )\n      const maxWidth = _.sum(\n        column.columns.map(col => _.getFirstDefined(resizedValue(col), col.width, col.maxWidth))\n      )\n\n      const theadGroupThProps = _.splitProps(\n        getTheadGroupThProps(finalState, undefined, column, this)\n      )\n      const columnHeaderProps = _.splitProps(\n        column.getHeaderProps(finalState, undefined, column, this)\n      )\n\n      const classes = [\n        column.headerClassName,\n        theadGroupThProps.className,\n        columnHeaderProps.className,\n      ]\n\n      const styles = {\n        ...column.headerStyle,\n        ...theadGroupThProps.style,\n        ...columnHeaderProps.style,\n      }\n\n      const rest = {\n        ...theadGroupThProps.rest,\n        ...columnHeaderProps.rest,\n      }\n\n      const flexStyles = {\n        flex: `${flex} 0 auto`,\n        width: _.asPx(width),\n        maxWidth: _.asPx(maxWidth),\n      }\n\n      return (\n        <ThComponent\n          key={`${i}-${column.id}`}\n          className={classnames(classes)}\n          style={{\n            ...styles,\n            ...flexStyles,\n          }}\n          {...rest}\n        >\n          {_.normalizeComponent(column.Header, {\n            data: sortedData,\n            column,\n          })}\n        </ThComponent>\n      )\n    }\n\n    const makeHeaderGroups = () => {\n      const theadGroupProps = _.splitProps(\n        getTheadGroupProps(finalState, undefined, undefined, this)\n      )\n      const theadGroupTrProps = _.splitProps(\n        getTheadGroupTrProps(finalState, undefined, undefined, this)\n      )\n      return (\n        <TheadComponent\n          className={classnames('-headerGroups', theadGroupProps.className)}\n          style={{\n            ...theadGroupProps.style,\n            minWidth: `${rowMinWidth}px`,\n          }}\n          {...theadGroupProps.rest}\n        >\n          <TrComponent\n            className={theadGroupTrProps.className}\n            style={theadGroupTrProps.style}\n            {...theadGroupTrProps.rest}\n          >\n            {headerGroups.map(makeHeaderGroup)}\n          </TrComponent>\n        </TheadComponent>\n      )\n    }\n\n    const makeHeader = (column, i) => {\n      const resizedCol = resized.find(x => x.id === column.id) || {}\n      const sort = sorted.find(d => d.id === column.id)\n      const show = typeof column.show === 'function' ? column.show() : column.show\n      const width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth)\n      const maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth)\n      const theadThProps = _.splitProps(getTheadThProps(finalState, undefined, column, this))\n      const columnHeaderProps = _.splitProps(\n        column.getHeaderProps(finalState, undefined, column, this)\n      )\n\n      const classes = [column.headerClassName, theadThProps.className, columnHeaderProps.className]\n\n      const styles = {\n        ...column.headerStyle,\n        ...theadThProps.style,\n        ...columnHeaderProps.style,\n      }\n\n      const rest = {\n        ...theadThProps.rest,\n        ...columnHeaderProps.rest,\n      }\n\n      const isResizable = _.getFirstDefined(column.resizable, resizable, false)\n      const resizer = isResizable ? (\n        <ResizerComponent\n          onMouseDown={e => this.resizeColumnStart(e, column, false)}\n          onTouchStart={e => this.resizeColumnStart(e, column, true)}\n          {...getResizerProps('finalState', undefined, column, this)}\n        />\n      ) : null\n\n      const isSortable = _.getFirstDefined(column.sortable, sortable, false)\n\n      return (\n        <ThComponent\n          key={`${i}-${column.id}`}\n          className={classnames(\n            classes,\n            isResizable && 'rt-resizable-header',\n            sort ? (sort.desc ? '-sort-desc' : '-sort-asc') : '',\n            isSortable && '-cursor-pointer',\n            !show && '-hidden',\n            pivotBy && pivotBy.slice(0, -1).includes(column.id) && 'rt-header-pivot'\n          )}\n          style={{\n            ...styles,\n            flex: `${width} 0 auto`,\n            width: _.asPx(width),\n            maxWidth: _.asPx(maxWidth),\n          }}\n          toggleSort={e => {\n            if (isSortable) this.sortColumn(column, multiSort ? e.shiftKey : false)\n          }}\n          {...rest}\n        >\n          <div className={classnames(isResizable && 'rt-resizable-header-content')}>\n            {_.normalizeComponent(column.Header, {\n              data: sortedData,\n              column,\n            })}\n          </div>\n          {resizer}\n        </ThComponent>\n      )\n    }\n\n    const makeHeaders = () => {\n      const theadProps = _.splitProps(getTheadProps(finalState, undefined, undefined, this))\n      const theadTrProps = _.splitProps(getTheadTrProps(finalState, undefined, undefined, this))\n      return (\n        <TheadComponent\n          className={classnames('-header', theadProps.className)}\n          style={{\n            ...theadProps.style,\n            minWidth: `${rowMinWidth}px`,\n          }}\n          {...theadProps.rest}\n        >\n          <TrComponent\n            className={theadTrProps.className}\n            style={theadTrProps.style}\n            {...theadTrProps.rest}\n          >\n            {allVisibleColumns.map(makeHeader)}\n          </TrComponent>\n        </TheadComponent>\n      )\n    }\n\n    const makeFilter = (column, i) => {\n      const resizedCol = resized.find(x => x.id === column.id) || {}\n      const width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth)\n      const maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth)\n      const theadFilterThProps = _.splitProps(\n        getTheadFilterThProps(finalState, undefined, column, this)\n      )\n      const columnHeaderProps = _.splitProps(\n        column.getHeaderProps(finalState, undefined, column, this)\n      )\n\n      const classes = [\n        column.headerClassName,\n        theadFilterThProps.className,\n        columnHeaderProps.className,\n      ]\n\n      const styles = {\n        ...column.headerStyle,\n        ...theadFilterThProps.style,\n        ...columnHeaderProps.style,\n      }\n\n      const rest = {\n        ...theadFilterThProps.rest,\n        ...columnHeaderProps.rest,\n      }\n\n      const filter = filtered.find(filter => filter.id === column.id)\n\n      const ResolvedFilterComponent = column.Filter || FilterComponent\n\n      const isFilterable = _.getFirstDefined(column.filterable, filterable, false)\n\n      return (\n        <ThComponent\n          key={`${i}-${column.id}`}\n          className={classnames(classes)}\n          style={{\n            ...styles,\n            flex: `${width} 0 auto`,\n            width: _.asPx(width),\n            maxWidth: _.asPx(maxWidth),\n          }}\n          {...rest}\n        >\n          {isFilterable\n            ? _.normalizeComponent(\n                ResolvedFilterComponent,\n                {\n                  column,\n                  filter,\n                  onChange: value => this.filterColumn(column, value),\n                },\n                defaultProps.column.Filter\n              )\n            : null}\n        </ThComponent>\n      )\n    }\n\n    const makeFilters = () => {\n      const theadFilterProps = _.splitProps(\n        getTheadFilterProps(finalState, undefined, undefined, this)\n      )\n      const theadFilterTrProps = _.splitProps(\n        getTheadFilterTrProps(finalState, undefined, undefined, this)\n      )\n      return (\n        <TheadComponent\n          className={classnames('-filters', theadFilterProps.className)}\n          style={{\n            ...theadFilterProps.style,\n            minWidth: `${rowMinWidth}px`,\n          }}\n          {...theadFilterProps.rest}\n        >\n          <TrComponent\n            className={theadFilterTrProps.className}\n            style={theadFilterTrProps.style}\n            {...theadFilterTrProps.rest}\n          >\n            {allVisibleColumns.map(makeFilter)}\n          </TrComponent>\n        </TheadComponent>\n      )\n    }\n\n    const makePageRow = (row, i, path = []) => {\n      const rowInfo = {\n        original: row[originalKey],\n        row,\n        index: row[indexKey],\n        viewIndex: (rowIndex += 1),\n        pageSize,\n        page,\n        level: path.length,\n        nestingPath: path.concat([i]),\n        aggregated: row[aggregatedKey],\n        groupedByPivot: row[groupedByPivotKey],\n        subRows: row[subRowsKey],\n      }\n      const isExpanded = _.get(expanded, rowInfo.nestingPath)\n      const trGroupProps = getTrGroupProps(finalState, rowInfo, undefined, this)\n      const trProps = _.splitProps(getTrProps(finalState, rowInfo, undefined, this))\n      return (\n        <TrGroupComponent key={rowInfo.nestingPath.join('_')} {...trGroupProps}>\n          <TrComponent\n            className={classnames(trProps.className, row._viewIndex % 2 ? '-even' : '-odd')}\n            style={trProps.style}\n            {...trProps.rest}\n          >\n            {allVisibleColumns.map((column, i2) => {\n              const resizedCol = resized.find(x => x.id === column.id) || {}\n              const show = typeof column.show === 'function' ? column.show() : column.show\n              const width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth)\n              const maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth)\n              const tdProps = _.splitProps(getTdProps(finalState, rowInfo, column, this))\n              const columnProps = _.splitProps(column.getProps(finalState, rowInfo, column, this))\n\n              const classes = [tdProps.className, column.className, columnProps.className]\n\n              const styles = {\n                ...tdProps.style,\n                ...column.style,\n                ...columnProps.style,\n              }\n\n              const cellInfo = {\n                ...rowInfo,\n                isExpanded,\n                column: { ...column },\n                value: rowInfo.row[column.id],\n                pivoted: column.pivoted,\n                expander: column.expander,\n                resized,\n                show,\n                width,\n                maxWidth,\n                tdProps,\n                columnProps,\n                classes,\n                styles,\n              }\n\n              const value = cellInfo.value\n\n              let useOnExpanderClick\n              let isBranch\n              let isPreview\n\n              const onExpanderClick = e => {\n                let newExpanded = _.clone(expanded)\n                if (isExpanded) {\n                  newExpanded = _.set(newExpanded, cellInfo.nestingPath, false)\n                } else {\n                  newExpanded = _.set(newExpanded, cellInfo.nestingPath, {})\n                }\n\n                return this.setStateWithData(\n                  {\n                    expanded: newExpanded,\n                  },\n                  () => onExpandedChange && onExpandedChange(newExpanded, cellInfo.nestingPath, e)\n                )\n              }\n\n              // Default to a standard cell\n              let resolvedCell = _.normalizeComponent(column.Cell, cellInfo, value)\n\n              // Resolve Renderers\n              const ResolvedAggregatedComponent =\n                column.Aggregated || (!column.aggregate ? AggregatedComponent : column.Cell)\n              const ResolvedExpanderComponent = column.Expander || ExpanderComponent\n              const ResolvedPivotValueComponent = column.PivotValue || PivotValueComponent\n              const DefaultResolvedPivotComponent =\n                PivotComponent ||\n                (props => (\n                  <div>\n                    <ResolvedExpanderComponent {...props} />\n                    <ResolvedPivotValueComponent {...props} />\n                  </div>\n                ))\n              const ResolvedPivotComponent = column.Pivot || DefaultResolvedPivotComponent\n\n              // Is this cell expandable?\n              if (cellInfo.pivoted || cellInfo.expander) {\n                // Make it expandable by defualt\n                cellInfo.expandable = true\n                useOnExpanderClick = true\n                // If pivoted, has no subRows, and does not have a subComponent,\n                // do not make expandable\n                if (cellInfo.pivoted && !cellInfo.subRows && !SubComponent) {\n                  cellInfo.expandable = false\n                }\n              }\n\n              if (cellInfo.pivoted) {\n                // Is this column a branch?\n                isBranch = rowInfo.row[pivotIDKey] === column.id && cellInfo.subRows\n                // Should this column be blank?\n                isPreview =\n                  pivotBy.indexOf(column.id) > pivotBy.indexOf(rowInfo.row[pivotIDKey]) &&\n                  cellInfo.subRows\n                // Pivot Cell Render Override\n                if (isBranch) {\n                  // isPivot\n                  resolvedCell = _.normalizeComponent(\n                    ResolvedPivotComponent,\n                    {\n                      ...cellInfo,\n                      value: row[pivotValKey],\n                    },\n                    row[pivotValKey]\n                  )\n                } else if (isPreview) {\n                  // Show the pivot preview\n                  resolvedCell = _.normalizeComponent(ResolvedAggregatedComponent, cellInfo, value)\n                } else {\n                  resolvedCell = null\n                }\n              } else if (cellInfo.aggregated) {\n                resolvedCell = _.normalizeComponent(ResolvedAggregatedComponent, cellInfo, value)\n              }\n\n              if (cellInfo.expander) {\n                resolvedCell = _.normalizeComponent(\n                  ResolvedExpanderComponent,\n                  cellInfo,\n                  row[pivotValKey]\n                )\n                if (pivotBy) {\n                  if (cellInfo.groupedByPivot) {\n                    resolvedCell = null\n                  }\n                  if (!cellInfo.subRows && !SubComponent) {\n                    resolvedCell = null\n                  }\n                }\n              }\n\n              const resolvedOnExpanderClick = useOnExpanderClick ? onExpanderClick : () => {}\n\n              // If there are multiple onClick events, make sure they don't\n              // override eachother. This should maybe be expanded to handle all\n              // function attributes\n              const interactionProps = {\n                onClick: resolvedOnExpanderClick,\n              }\n\n              if (tdProps.rest.onClick) {\n                interactionProps.onClick = e => {\n                  tdProps.rest.onClick(e, () => resolvedOnExpanderClick(e))\n                }\n              }\n\n              if (columnProps.rest.onClick) {\n                interactionProps.onClick = e => {\n                  columnProps.rest.onClick(e, () => resolvedOnExpanderClick(e))\n                }\n              }\n\n              // Return the cell\n              return (\n                <TdComponent\n                  // eslint-disable-next-line react/no-array-index-key\n                  key={`${i2}-${column.id}`}\n                  className={classnames(\n                    classes,\n                    !show && 'hidden',\n                    cellInfo.expandable && 'rt-expandable',\n                    (isBranch || isPreview) && 'rt-pivot'\n                  )}\n                  style={{\n                    ...styles,\n                    flex: `${width} 0 auto`,\n                    width: _.asPx(width),\n                    maxWidth: _.asPx(maxWidth),\n                  }}\n                  {...tdProps.rest}\n                  {...columnProps.rest}\n                  {...interactionProps}\n                >\n                  {resolvedCell}\n                </TdComponent>\n              )\n            })}\n          </TrComponent>\n          {rowInfo.subRows &&\n            isExpanded &&\n            rowInfo.subRows.map((d, i) => makePageRow(d, i, rowInfo.nestingPath))}\n          {SubComponent && !rowInfo.subRows && isExpanded && SubComponent(rowInfo)}\n        </TrGroupComponent>\n      )\n    }\n\n    const makePadColumn = (column, i) => {\n      const resizedCol = resized.find(x => x.id === column.id) || {}\n      const show = typeof column.show === 'function' ? column.show() : column.show\n      const width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth)\n      const flex = width\n      const maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth)\n      const tdProps = _.splitProps(getTdProps(finalState, undefined, column, this))\n      const columnProps = _.splitProps(column.getProps(finalState, undefined, column, this))\n\n      const classes = [tdProps.className, column.className, columnProps.className]\n\n      const styles = {\n        ...tdProps.style,\n        ...column.style,\n        ...columnProps.style,\n      }\n\n      return (\n        <TdComponent\n          key={`${i}-${column.id}`}\n          className={classnames(classes, !show && 'hidden')}\n          style={{\n            ...styles,\n            flex: `${flex} 0 auto`,\n            width: _.asPx(width),\n            maxWidth: _.asPx(maxWidth),\n          }}\n          {...tdProps.rest}\n        >\n          {_.normalizeComponent(PadRowComponent)}\n        </TdComponent>\n      )\n    }\n\n    const makePadRow = (row, i) => {\n      const trGroupProps = getTrGroupProps(finalState, undefined, undefined, this)\n      const trProps = _.splitProps(getTrProps(finalState, undefined, undefined, this))\n      return (\n        <TrGroupComponent key={`pad-${i}`} {...trGroupProps}>\n          <TrComponent\n            className={classnames(\n              '-padRow',\n              (pageRows.length + i) % 2 ? '-even' : '-odd',\n              trProps.className\n            )}\n            style={trProps.style || {}}\n          >\n            {allVisibleColumns.map(makePadColumn)}\n          </TrComponent>\n        </TrGroupComponent>\n      )\n    }\n\n    const makeColumnFooter = (column, i) => {\n      const resizedCol = resized.find(x => x.id === column.id) || {}\n      const show = typeof column.show === 'function' ? column.show() : column.show\n      const width = _.getFirstDefined(resizedCol.value, column.width, column.minWidth)\n      const maxWidth = _.getFirstDefined(resizedCol.value, column.width, column.maxWidth)\n      const tFootTdProps = _.splitProps(getTfootTdProps(finalState, undefined, undefined, this))\n      const columnProps = _.splitProps(column.getProps(finalState, undefined, column, this))\n      const columnFooterProps = _.splitProps(\n        column.getFooterProps(finalState, undefined, column, this)\n      )\n\n      const classes = [\n        tFootTdProps.className,\n        column.className,\n        columnProps.className,\n        columnFooterProps.className,\n      ]\n\n      const styles = {\n        ...tFootTdProps.style,\n        ...column.style,\n        ...columnProps.style,\n        ...columnFooterProps.style,\n      }\n\n      return (\n        <TdComponent\n          key={`${i}-${column.id}`}\n          className={classnames(classes, !show && 'hidden')}\n          style={{\n            ...styles,\n            flex: `${width} 0 auto`,\n            width: _.asPx(width),\n            maxWidth: _.asPx(maxWidth),\n          }}\n          {...columnProps.rest}\n          {...tFootTdProps.rest}\n          {...columnFooterProps.rest}\n        >\n          {_.normalizeComponent(column.Footer, {\n            data: sortedData,\n            column,\n          })}\n        </TdComponent>\n      )\n    }\n\n    const makeColumnFooters = () => {\n      const tFootProps = getTfootProps(finalState, undefined, undefined, this)\n      const tFootTrProps = _.splitProps(getTfootTrProps(finalState, undefined, undefined, this))\n      return (\n        <TfootComponent\n          className={tFootProps.className}\n          style={{\n            ...tFootProps.style,\n            minWidth: `${rowMinWidth}px`,\n          }}\n          {...tFootProps.rest}\n        >\n          <TrComponent\n            className={classnames(tFootTrProps.className)}\n            style={tFootTrProps.style}\n            {...tFootTrProps.rest}\n          >\n            {allVisibleColumns.map(makeColumnFooter)}\n          </TrComponent>\n        </TfootComponent>\n      )\n    }\n\n    const makePagination = () => {\n      const paginationProps = _.splitProps(\n        getPaginationProps(finalState, undefined, undefined, this)\n      )\n      return (\n        <PaginationComponent\n          {...resolvedState}\n          pages={pages}\n          canPrevious={canPrevious}\n          canNext={canNext}\n          onPageChange={this.onPageChange}\n          onPageSizeChange={this.onPageSizeChange}\n          className={paginationProps.className}\n          style={paginationProps.style}\n          {...paginationProps.rest}\n        />\n      )\n    }\n\n    const makeTable = () => {\n      const pagination = makePagination()\n      return (\n        <div\n          className={classnames('ReactTable', className, rootProps.className)}\n          style={{\n            ...style,\n            ...rootProps.style,\n          }}\n          {...rootProps.rest}\n        >\n          {showPagination && showPaginationTop ? (\n            <div className=\"pagination-top\">{pagination}</div>\n          ) : null}\n          <TableComponent\n            className={classnames(tableProps.className, currentlyResizing ? 'rt-resizing' : '')}\n            style={tableProps.style}\n            {...tableProps.rest}\n          >\n            {hasHeaderGroups ? makeHeaderGroups() : null}\n            {makeHeaders()}\n            {hasFilters ? makeFilters() : null}\n            <TbodyComponent\n              className={classnames(tBodyProps.className)}\n              style={{\n                ...tBodyProps.style,\n                minWidth: `${rowMinWidth}px`,\n              }}\n              {...tBodyProps.rest}\n            >\n              {pageRows.map((d, i) => makePageRow(d, i))}\n              {padRows.map(makePadRow)}\n            </TbodyComponent>\n            {hasColumnFooter ? makeColumnFooters() : null}\n          </TableComponent>\n          {showPagination && showPaginationBottom ? (\n            <div className=\"pagination-bottom\">{pagination}</div>\n          ) : null}\n          {!pageRows.length && (\n            <NoDataComponent {...noDataProps}>{_.normalizeComponent(noDataText)}</NoDataComponent>\n          )}\n          <LoadingComponent loading={loading} loadingText={loadingText} {...loadingProps} />\n        </div>\n      )\n    }\n\n    // childProps are optionally passed to a function-as-a-child\n    return children ? children(finalState, makeTable, this) : makeTable()\n  }\n}\n"]} \ No newline at end of file diff --git a/lib/lifecycle.js b/lib/lifecycle.js new file mode 100644 index 0000000000..ce51d267a2 --- /dev/null +++ b/lib/lifecycle.js @@ -0,0 +1,131 @@ +'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; }; }(); + +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 (Base) { + return function (_Base) { + _inherits(_class, _Base); + + function _class() { + _classCallCheck(this, _class); + + return _possibleConstructorReturn(this, (_class.__proto__ || Object.getPrototypeOf(_class)).apply(this, arguments)); + } + + _createClass(_class, [{ + key: 'componentWillMount', + value: function componentWillMount() { + this.setStateWithData(this.getDataModel(this.getResolvedState(), true)); + } + }, { + key: 'componentDidMount', + value: function componentDidMount() { + this.fireFetchData(); + } + }, { + key: 'componentWillReceiveProps', + value: function componentWillReceiveProps(nextProps, nextState) { + var oldState = this.getResolvedState(); + var newState = this.getResolvedState(nextProps, nextState); + + // Do a deep compare of new and old `defaultOption` and + // if they are different reset `option = defaultOption` + var defaultableOptions = ['sorted', 'filtered', 'resized', 'expanded']; + defaultableOptions.forEach(function (x) { + var defaultName = 'default' + (x.charAt(0).toUpperCase() + x.slice(1)); + if (JSON.stringify(oldState[defaultName]) !== JSON.stringify(newState[defaultName])) { + newState[x] = newState[defaultName]; + } + }); + + // If they change these table options, we need to reset defaults + // or else we could get into a state where the user has changed the UI + // and then disabled the ability to change it back. + // e.g. If `filterable` has changed, set `filtered = defaultFiltered` + var resettableOptions = ['sortable', 'filterable', 'resizable']; + resettableOptions.forEach(function (x) { + if (oldState[x] !== newState[x]) { + var baseName = x.replace('able', ''); + var optionName = baseName + 'ed'; + var defaultName = 'default' + (optionName.charAt(0).toUpperCase() + optionName.slice(1)); + newState[optionName] = newState[defaultName]; + } + }); + + // Props that trigger a data update + if (oldState.data !== newState.data || oldState.columns !== newState.columns || oldState.pivotBy !== newState.pivotBy || oldState.sorted !== newState.sorted || oldState.filtered !== newState.filtered) { + this.setStateWithData(this.getDataModel(newState, oldState.data !== newState.data)); + } + } + }, { + key: 'setStateWithData', + value: function setStateWithData(newState, cb) { + var _this2 = this; + + var oldState = this.getResolvedState(); + var newResolvedState = this.getResolvedState({}, newState); + var freezeWhenExpanded = newResolvedState.freezeWhenExpanded; + + // Default to unfrozen state + + newResolvedState.frozen = false; + + // If freezeWhenExpanded is set, check for frozen conditions + if (freezeWhenExpanded) { + // if any rows are expanded, freeze the existing data and sorting + var keys = Object.keys(newResolvedState.expanded); + for (var i = 0; i < keys.length; i += 1) { + if (newResolvedState.expanded[keys[i]]) { + newResolvedState.frozen = true; + break; + } + } + } + + // If the data isn't frozen and either the data or + // sorting model has changed, update the data + if (oldState.frozen && !newResolvedState.frozen || oldState.sorted !== newResolvedState.sorted || oldState.filtered !== newResolvedState.filtered || oldState.showFilters !== newResolvedState.showFilters || !newResolvedState.frozen && oldState.resolvedData !== newResolvedState.resolvedData) { + // Handle collapseOnsortedChange & collapseOnDataChange + if (oldState.sorted !== newResolvedState.sorted && this.props.collapseOnSortingChange || oldState.filtered !== newResolvedState.filtered || oldState.showFilters !== newResolvedState.showFilters || oldState.sortedData && !newResolvedState.frozen && oldState.resolvedData !== newResolvedState.resolvedData && this.props.collapseOnDataChange) { + newResolvedState.expanded = {}; + } + + Object.assign(newResolvedState, this.getSortedData(newResolvedState)); + } + + // Set page to 0 if filters change + if (oldState.filtered !== newResolvedState.filtered) { + newResolvedState.page = 0; + } + + // Calculate pageSize all the time + if (newResolvedState.sortedData) { + newResolvedState.pages = newResolvedState.manual ? newResolvedState.pages : Math.ceil(newResolvedState.sortedData.length / newResolvedState.pageSize); + newResolvedState.page = newResolvedState.manual ? newResolvedState.page : Math.max(newResolvedState.page >= newResolvedState.pages ? newResolvedState.pages - 1 : newResolvedState.page, 0); + } + + return this.setState(newResolvedState, function () { + if (cb) { + cb(); + } + if (oldState.page !== newResolvedState.page || oldState.pageSize !== newResolvedState.pageSize || oldState.sorted !== newResolvedState.sorted || oldState.filtered !== newResolvedState.filtered) { + _this2.fireFetchData(); + } + }); + } + }]); + + return _class; + }(Base); +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/lifecycle.js"],"names":["setStateWithData","getDataModel","getResolvedState","fireFetchData","nextProps","nextState","oldState","newState","defaultableOptions","forEach","defaultName","x","charAt","toUpperCase","slice","JSON","stringify","resettableOptions","baseName","replace","optionName","data","columns","pivotBy","sorted","filtered","cb","newResolvedState","freezeWhenExpanded","frozen","keys","Object","expanded","i","length","showFilters","resolvedData","props","collapseOnSortingChange","sortedData","collapseOnDataChange","assign","getSortedData","page","pages","manual","Math","ceil","pageSize","max","setState","Base"],"mappings":"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","file":"lifecycle.js","sourcesContent":["export default Base =>\n  class extends Base {\n    componentWillMount () {\n      this.setStateWithData(this.getDataModel(this.getResolvedState(), true))\n    }\n\n    componentDidMount () {\n      this.fireFetchData()\n    }\n\n    componentWillReceiveProps (nextProps, nextState) {\n      const oldState = this.getResolvedState()\n      const newState = this.getResolvedState(nextProps, nextState)\n\n      // Do a deep compare of new and old `defaultOption` and\n      // if they are different reset `option = defaultOption`\n      const defaultableOptions = ['sorted', 'filtered', 'resized', 'expanded']\n      defaultableOptions.forEach(x => {\n        const defaultName = `default${x.charAt(0).toUpperCase() + x.slice(1)}`\n        if (JSON.stringify(oldState[defaultName]) !== JSON.stringify(newState[defaultName])) {\n          newState[x] = newState[defaultName]\n        }\n      })\n\n      // If they change these table options, we need to reset defaults\n      // or else we could get into a state where the user has changed the UI\n      // and then disabled the ability to change it back.\n      // e.g. If `filterable` has changed, set `filtered = defaultFiltered`\n      const resettableOptions = ['sortable', 'filterable', 'resizable']\n      resettableOptions.forEach(x => {\n        if (oldState[x] !== newState[x]) {\n          const baseName = x.replace('able', '')\n          const optionName = `${baseName}ed`\n          const defaultName = `default${optionName.charAt(0).toUpperCase() + optionName.slice(1)}`\n          newState[optionName] = newState[defaultName]\n        }\n      })\n\n      // Props that trigger a data update\n      if (\n        oldState.data !== newState.data ||\n        oldState.columns !== newState.columns ||\n        oldState.pivotBy !== newState.pivotBy ||\n        oldState.sorted !== newState.sorted ||\n        oldState.filtered !== newState.filtered\n      ) {\n        this.setStateWithData(this.getDataModel(newState, oldState.data !== newState.data))\n      }\n    }\n\n    setStateWithData (newState, cb) {\n      const oldState = this.getResolvedState()\n      const newResolvedState = this.getResolvedState({}, newState)\n      const { freezeWhenExpanded } = newResolvedState\n\n      // Default to unfrozen state\n      newResolvedState.frozen = false\n\n      // If freezeWhenExpanded is set, check for frozen conditions\n      if (freezeWhenExpanded) {\n        // if any rows are expanded, freeze the existing data and sorting\n        const keys = Object.keys(newResolvedState.expanded)\n        for (let i = 0; i < keys.length; i += 1) {\n          if (newResolvedState.expanded[keys[i]]) {\n            newResolvedState.frozen = true\n            break\n          }\n        }\n      }\n\n      // If the data isn't frozen and either the data or\n      // sorting model has changed, update the data\n      if (\n        (oldState.frozen && !newResolvedState.frozen) ||\n        oldState.sorted !== newResolvedState.sorted ||\n        oldState.filtered !== newResolvedState.filtered ||\n        oldState.showFilters !== newResolvedState.showFilters ||\n        (!newResolvedState.frozen && oldState.resolvedData !== newResolvedState.resolvedData)\n      ) {\n        // Handle collapseOnsortedChange & collapseOnDataChange\n        if (\n          (oldState.sorted !== newResolvedState.sorted && this.props.collapseOnSortingChange) ||\n          oldState.filtered !== newResolvedState.filtered ||\n          oldState.showFilters !== newResolvedState.showFilters ||\n          (oldState.sortedData &&\n            !newResolvedState.frozen &&\n            oldState.resolvedData !== newResolvedState.resolvedData &&\n            this.props.collapseOnDataChange)\n        ) {\n          newResolvedState.expanded = {}\n        }\n\n        Object.assign(newResolvedState, this.getSortedData(newResolvedState))\n      }\n\n      // Set page to 0 if filters change\n      if (oldState.filtered !== newResolvedState.filtered) {\n        newResolvedState.page = 0\n      }\n\n      // Calculate pageSize all the time\n      if (newResolvedState.sortedData) {\n        newResolvedState.pages = newResolvedState.manual\n          ? newResolvedState.pages\n          : Math.ceil(newResolvedState.sortedData.length / newResolvedState.pageSize)\n        newResolvedState.page = newResolvedState.manual ? newResolvedState.page : Math.max(\n          newResolvedState.page >= newResolvedState.pages\n            ? newResolvedState.pages - 1\n            : newResolvedState.page,\n          0\n        )\n      }\n\n      return this.setState(newResolvedState, () => {\n        if (cb) {\n          cb()\n        }\n        if (\n          oldState.page !== newResolvedState.page ||\n          oldState.pageSize !== newResolvedState.pageSize ||\n          oldState.sorted !== newResolvedState.sorted ||\n          oldState.filtered !== newResolvedState.filtered\n        ) {\n          this.fireFetchData()\n        }\n      })\n    }\n  }\n"]} \ No newline at end of file diff --git a/lib/methods.js b/lib/methods.js new file mode 100644 index 0000000000..d7ee428143 --- /dev/null +++ b/lib/methods.js @@ -0,0 +1,752 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); + +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); + +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 _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; } + +exports.default = function (Base) { + return function (_Base) { + _inherits(_class, _Base); + + function _class() { + _classCallCheck(this, _class); + + return _possibleConstructorReturn(this, (_class.__proto__ || Object.getPrototypeOf(_class)).apply(this, arguments)); + } + + _createClass(_class, [{ + key: 'getResolvedState', + value: function getResolvedState(props, state) { + var resolvedState = _extends({}, _utils2.default.compactObject(this.state), _utils2.default.compactObject(this.props), _utils2.default.compactObject(state), _utils2.default.compactObject(props)); + return resolvedState; + } + }, { + key: 'getDataModel', + value: function getDataModel(newState, dataChanged) { + var _this2 = this; + + var columns = newState.columns, + _newState$pivotBy = newState.pivotBy, + pivotBy = _newState$pivotBy === undefined ? [] : _newState$pivotBy, + data = newState.data, + resolveData = newState.resolveData, + pivotIDKey = newState.pivotIDKey, + pivotValKey = newState.pivotValKey, + subRowsKey = newState.subRowsKey, + aggregatedKey = newState.aggregatedKey, + nestingLevelKey = newState.nestingLevelKey, + originalKey = newState.originalKey, + indexKey = newState.indexKey, + groupedByPivotKey = newState.groupedByPivotKey, + SubComponent = newState.SubComponent; + + // Determine Header Groups + + var hasHeaderGroups = false; + columns.forEach(function (column) { + if (column.columns) { + hasHeaderGroups = true; + } + }); + + var columnsWithExpander = [].concat(_toConsumableArray(columns)); + + var expanderColumn = columns.find(function (col) { + return col.expander || col.columns && col.columns.some(function (col2) { + return col2.expander; + }); + }); + // The actual expander might be in the columns field of a group column + if (expanderColumn && !expanderColumn.expander) { + expanderColumn = expanderColumn.columns.find(function (col) { + return col.expander; + }); + } + + // If we have SubComponent's we need to make sure we have an expander column + if (SubComponent && !expanderColumn) { + expanderColumn = { expander: true }; + columnsWithExpander = [expanderColumn].concat(_toConsumableArray(columnsWithExpander)); + } + + var makeDecoratedColumn = function makeDecoratedColumn(column, parentColumn) { + var dcol = void 0; + if (column.expander) { + dcol = _extends({}, _this2.props.column, _this2.props.expanderDefaults, column); + } else { + dcol = _extends({}, _this2.props.column, column); + } + + // Ensure minWidth is not greater than maxWidth if set + if (dcol.maxWidth < dcol.minWidth) { + dcol.minWidth = dcol.maxWidth; + } + + if (parentColumn) { + dcol.parentColumn = parentColumn; + } + + // First check for string accessor + if (typeof dcol.accessor === 'string') { + dcol.id = dcol.id || dcol.accessor; + var accessorString = dcol.accessor; + dcol.accessor = function (row) { + return _utils2.default.get(row, accessorString); + }; + return dcol; + } + + // Fall back to functional accessor (but require an ID) + if (dcol.accessor && !dcol.id) { + console.warn(dcol); + throw new Error('A column id is required if using a non-string accessor for column above.'); + } + + // Fall back to an undefined accessor + if (!dcol.accessor) { + dcol.accessor = function () { + return undefined; + }; + } + + return dcol; + }; + + var allDecoratedColumns = []; + + // Decorate the columns + var decorateAndAddToAll = function decorateAndAddToAll(column, parentColumn) { + var decoratedColumn = makeDecoratedColumn(column, parentColumn); + allDecoratedColumns.push(decoratedColumn); + return decoratedColumn; + }; + + var decoratedColumns = columnsWithExpander.map(function (column) { + if (column.columns) { + return _extends({}, column, { + columns: column.columns.map(function (d) { + return decorateAndAddToAll(d, column); + }) + }); + } + return decorateAndAddToAll(column); + }); + + // Build the visible columns, headers and flat column list + var visibleColumns = decoratedColumns.slice(); + var allVisibleColumns = []; + + visibleColumns = visibleColumns.map(function (column) { + if (column.columns) { + var visibleSubColumns = column.columns.filter(function (d) { + return pivotBy.indexOf(d.id) > -1 ? false : _utils2.default.getFirstDefined(d.show, true); + }); + return _extends({}, column, { + columns: visibleSubColumns + }); + } + return column; + }); + + visibleColumns = visibleColumns.filter(function (column) { + return column.columns ? column.columns.length : pivotBy.indexOf(column.id) > -1 ? false : _utils2.default.getFirstDefined(column.show, true); + }); + + // Find any custom pivot location + var pivotIndex = visibleColumns.findIndex(function (col) { + return col.pivot; + }); + + // Handle Pivot Columns + if (pivotBy.length) { + // Retrieve the pivot columns in the correct pivot order + var pivotColumns = []; + pivotBy.forEach(function (pivotID) { + var found = allDecoratedColumns.find(function (d) { + return d.id === pivotID; + }); + if (found) { + pivotColumns.push(found); + } + }); + + var PivotParentColumn = pivotColumns.reduce(function (prev, current) { + return prev && prev === current.parentColumn && current.parentColumn; + }, pivotColumns[0].parentColumn); + + var PivotGroupHeader = hasHeaderGroups && PivotParentColumn.Header; + PivotGroupHeader = PivotGroupHeader || function () { + return _react2.default.createElement( + 'strong', + null, + 'Pivoted' + ); + }; + + var pivotColumnGroup = { + Header: PivotGroupHeader, + columns: pivotColumns.map(function (col) { + return _extends({}, _this2.props.pivotDefaults, col, { + pivoted: true + }); + }) + + // Place the pivotColumns back into the visibleColumns + };if (pivotIndex >= 0) { + pivotColumnGroup = _extends({}, visibleColumns[pivotIndex], pivotColumnGroup); + visibleColumns.splice(pivotIndex, 1, pivotColumnGroup); + } else { + visibleColumns.unshift(pivotColumnGroup); + } + } + + // Build Header Groups + var headerGroups = []; + var currentSpan = []; + + // A convenience function to add a header and reset the currentSpan + var addHeader = function addHeader(columns, column) { + headerGroups.push(_extends({}, _this2.props.column, column, { + columns: columns + })); + currentSpan = []; + }; + + // Build flast list of allVisibleColumns and HeaderGroups + visibleColumns.forEach(function (column) { + if (column.columns) { + allVisibleColumns = allVisibleColumns.concat(column.columns); + if (currentSpan.length > 0) { + addHeader(currentSpan); + } + addHeader(column.columns, column); + return; + } + allVisibleColumns.push(column); + currentSpan.push(column); + }); + if (hasHeaderGroups && currentSpan.length > 0) { + addHeader(currentSpan); + } + + // Access the data + var accessRow = function accessRow(d, i) { + var _row; + + var level = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0; + + var row = (_row = {}, _defineProperty(_row, originalKey, d), _defineProperty(_row, indexKey, i), _defineProperty(_row, subRowsKey, d[subRowsKey]), _defineProperty(_row, nestingLevelKey, level), _row); + allDecoratedColumns.forEach(function (column) { + if (column.expander) return; + row[column.id] = column.accessor(d); + }); + if (row[subRowsKey]) { + row[subRowsKey] = row[subRowsKey].map(function (d, i) { + return accessRow(d, i, level + 1); + }); + } + return row; + }; + + // // If the data hasn't changed, just use the cached data + var resolvedData = this.resolvedData; + // If the data has changed, run the data resolver and cache the result + if (!this.resolvedData || dataChanged) { + resolvedData = resolveData(data); + this.resolvedData = resolvedData; + } + // Use the resolved data + resolvedData = resolvedData.map(function (d, i) { + return accessRow(d, i); + }); + + // TODO: Make it possible to fabricate nested rows without pivoting + var aggregatingColumns = allVisibleColumns.filter(function (d) { + return !d.expander && d.aggregate; + }); + + // If pivoting, recursively group the data + var aggregate = function aggregate(rows) { + var aggregationValues = {}; + aggregatingColumns.forEach(function (column) { + var values = rows.map(function (d) { + return d[column.id]; + }); + aggregationValues[column.id] = column.aggregate(values, rows); + }); + return aggregationValues; + }; + if (pivotBy.length) { + var groupRecursively = function groupRecursively(rows, keys) { + var i = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0; + + // This is the last level, just return the rows + if (i === keys.length) { + return rows; + } + // Group the rows together for this level + var groupedRows = Object.entries(_utils2.default.groupBy(rows, keys[i])).map(function (_ref) { + var _ref3; + + var _ref2 = _slicedToArray(_ref, 2), + key = _ref2[0], + value = _ref2[1]; + + return _ref3 = {}, _defineProperty(_ref3, pivotIDKey, keys[i]), _defineProperty(_ref3, pivotValKey, key), _defineProperty(_ref3, keys[i], key), _defineProperty(_ref3, subRowsKey, value), _defineProperty(_ref3, nestingLevelKey, i), _defineProperty(_ref3, groupedByPivotKey, true), _ref3; + }); + // Recurse into the subRows + groupedRows = groupedRows.map(function (rowGroup) { + var _extends2; + + var subRows = groupRecursively(rowGroup[subRowsKey], keys, i + 1); + return _extends({}, rowGroup, (_extends2 = {}, _defineProperty(_extends2, subRowsKey, subRows), _defineProperty(_extends2, aggregatedKey, true), _extends2), aggregate(subRows)); + }); + return groupedRows; + }; + resolvedData = groupRecursively(resolvedData, pivotBy); + } + + return _extends({}, newState, { + resolvedData: resolvedData, + allVisibleColumns: allVisibleColumns, + headerGroups: headerGroups, + allDecoratedColumns: allDecoratedColumns, + hasHeaderGroups: hasHeaderGroups + }); + } + }, { + key: 'getSortedData', + value: function getSortedData(resolvedState) { + var manual = resolvedState.manual, + sorted = resolvedState.sorted, + filtered = resolvedState.filtered, + defaultFilterMethod = resolvedState.defaultFilterMethod, + resolvedData = resolvedState.resolvedData, + allVisibleColumns = resolvedState.allVisibleColumns, + allDecoratedColumns = resolvedState.allDecoratedColumns; + + + var sortMethodsByColumnID = {}; + + allDecoratedColumns.filter(function (col) { + return col.sortMethod; + }).forEach(function (col) { + sortMethodsByColumnID[col.id] = col.sortMethod; + }); + + // Resolve the data from either manual data or sorted data + return { + sortedData: manual ? resolvedData : this.sortData(this.filterData(resolvedData, filtered, defaultFilterMethod, allVisibleColumns), sorted, sortMethodsByColumnID) + }; + } + }, { + key: 'fireFetchData', + value: function fireFetchData() { + this.props.onFetchData(this.getResolvedState(), this); + } + }, { + key: 'getPropOrState', + value: function getPropOrState(key) { + return _utils2.default.getFirstDefined(this.props[key], this.state[key]); + } + }, { + key: 'getStateOrProp', + value: function getStateOrProp(key) { + return _utils2.default.getFirstDefined(this.state[key], this.props[key]); + } + }, { + key: 'filterData', + value: function filterData(data, filtered, defaultFilterMethod, allVisibleColumns) { + var _this3 = this; + + var filteredData = data; + + if (filtered.length) { + filteredData = filtered.reduce(function (filteredSoFar, nextFilter) { + var column = allVisibleColumns.find(function (x) { + return x.id === nextFilter.id; + }); + + // Don't filter hidden columns or columns that have had their filters disabled + if (!column || column.filterable === false) { + return filteredSoFar; + } + + var filterMethod = column.filterMethod || defaultFilterMethod; + + // If 'filterAll' is set to true, pass the entire dataset to the filter method + if (column.filterAll) { + return filterMethod(nextFilter, filteredSoFar, column); + } + return filteredSoFar.filter(function (row) { + return filterMethod(nextFilter, row, column); + }); + }, filteredData); + + // Apply the filter to the subrows if we are pivoting, and then + // filter any rows without subcolumns because it would be strange to show + filteredData = filteredData.map(function (row) { + if (!row[_this3.props.subRowsKey]) { + return row; + } + return _extends({}, row, _defineProperty({}, _this3.props.subRowsKey, _this3.filterData(row[_this3.props.subRowsKey], filtered, defaultFilterMethod, allVisibleColumns))); + }).filter(function (row) { + if (!row[_this3.props.subRowsKey]) { + return true; + } + return row[_this3.props.subRowsKey].length > 0; + }); + } + + return filteredData; + } + }, { + key: 'sortData', + value: function sortData(data, sorted) { + var _this4 = this; + + var sortMethodsByColumnID = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + if (!sorted.length) { + return data; + } + + var sortedData = (this.props.orderByMethod || _utils2.default.orderBy)(data, sorted.map(function (sort) { + // Support custom sorting methods for each column + if (sortMethodsByColumnID[sort.id]) { + return function (a, b) { + return sortMethodsByColumnID[sort.id](a[sort.id], b[sort.id], sort.desc); + }; + } + return function (a, b) { + return _this4.props.defaultSortMethod(a[sort.id], b[sort.id], sort.desc); + }; + }), sorted.map(function (d) { + return !d.desc; + }), this.props.indexKey); + + sortedData.forEach(function (row) { + if (!row[_this4.props.subRowsKey]) { + return; + } + row[_this4.props.subRowsKey] = _this4.sortData(row[_this4.props.subRowsKey], sorted, sortMethodsByColumnID); + }); + + return sortedData; + } + }, { + key: 'getMinRows', + value: function getMinRows() { + return _utils2.default.getFirstDefined(this.props.minRows, this.getStateOrProp('pageSize')); + } + + // User actions + + }, { + key: 'onPageChange', + value: function onPageChange(page) { + var _props = this.props, + onPageChange = _props.onPageChange, + collapseOnPageChange = _props.collapseOnPageChange; + + + var newState = { page: page }; + if (collapseOnPageChange) { + newState.expanded = {}; + } + this.setStateWithData(newState, function () { + return onPageChange && onPageChange(page); + }); + } + }, { + key: 'onPageSizeChange', + value: function onPageSizeChange(newPageSize) { + var onPageSizeChange = this.props.onPageSizeChange; + + var _getResolvedState = this.getResolvedState(), + pageSize = _getResolvedState.pageSize, + page = _getResolvedState.page; + + // Normalize the page to display + + + var currentRow = pageSize * page; + var newPage = Math.floor(currentRow / newPageSize); + + this.setStateWithData({ + pageSize: newPageSize, + page: newPage + }, function () { + return onPageSizeChange && onPageSizeChange(newPageSize, newPage); + }); + } + }, { + key: 'sortColumn', + value: function sortColumn(column, additive) { + var _getResolvedState2 = this.getResolvedState(), + sorted = _getResolvedState2.sorted, + skipNextSort = _getResolvedState2.skipNextSort, + defaultSortDesc = _getResolvedState2.defaultSortDesc; + + var firstSortDirection = Object.prototype.hasOwnProperty.call(column, 'defaultSortDesc') ? column.defaultSortDesc : defaultSortDesc; + var secondSortDirection = !firstSortDirection; + + // we can't stop event propagation from the column resize move handlers + // attached to the document because of react's synthetic events + // so we have to prevent the sort function from actually sorting + // if we click on the column resize element within a header. + if (skipNextSort) { + this.setStateWithData({ + skipNextSort: false + }); + return; + } + + var onSortedChange = this.props.onSortedChange; + + + var newSorted = _utils2.default.clone(sorted || []).map(function (d) { + d.desc = _utils2.default.isSortingDesc(d); + return d; + }); + if (!_utils2.default.isArray(column)) { + // Single-Sort + var existingIndex = newSorted.findIndex(function (d) { + return d.id === column.id; + }); + if (existingIndex > -1) { + var existing = newSorted[existingIndex]; + if (existing.desc === secondSortDirection) { + if (additive) { + newSorted.splice(existingIndex, 1); + } else { + existing.desc = firstSortDirection; + newSorted = [existing]; + } + } else { + existing.desc = secondSortDirection; + if (!additive) { + newSorted = [existing]; + } + } + } else if (additive) { + newSorted.push({ + id: column.id, + desc: firstSortDirection + }); + } else { + newSorted = [{ + id: column.id, + desc: firstSortDirection + }]; + } + } else { + // Multi-Sort + var _existingIndex = newSorted.findIndex(function (d) { + return d.id === column[0].id; + }); + // Existing Sorted Column + if (_existingIndex > -1) { + var _existing = newSorted[_existingIndex]; + if (_existing.desc === secondSortDirection) { + if (additive) { + newSorted.splice(_existingIndex, column.length); + } else { + column.forEach(function (d, i) { + newSorted[_existingIndex + i].desc = firstSortDirection; + }); + } + } else { + column.forEach(function (d, i) { + newSorted[_existingIndex + i].desc = secondSortDirection; + }); + } + if (!additive) { + newSorted = newSorted.slice(_existingIndex, column.length); + } + // New Sort Column + } else if (additive) { + newSorted = newSorted.concat(column.map(function (d) { + return { + id: d.id, + desc: firstSortDirection + }; + })); + } else { + newSorted = column.map(function (d) { + return { + id: d.id, + desc: firstSortDirection + }; + }); + } + } + + this.setStateWithData({ + page: !sorted.length && newSorted.length || !additive ? 0 : this.state.page, + sorted: newSorted + }, function () { + return onSortedChange && onSortedChange(newSorted, column, additive); + }); + } + }, { + key: 'filterColumn', + value: function filterColumn(column, value) { + var _getResolvedState3 = this.getResolvedState(), + filtered = _getResolvedState3.filtered; + + var onFilteredChange = this.props.onFilteredChange; + + // Remove old filter first if it exists + + var newFiltering = (filtered || []).filter(function (x) { + return x.id !== column.id; + }); + + if (value !== '') { + newFiltering.push({ + id: column.id, + value: value + }); + } + + this.setStateWithData({ + filtered: newFiltering + }, function () { + return onFilteredChange && onFilteredChange(newFiltering, column, value); + }); + } + }, { + key: 'resizeColumnStart', + value: function resizeColumnStart(event, column, isTouch) { + var _this5 = this; + + event.stopPropagation(); + var parentWidth = event.target.parentElement.getBoundingClientRect().width; + + var pageX = void 0; + if (isTouch) { + pageX = event.changedTouches[0].pageX; + } else { + pageX = event.pageX; + } + + this.trapEvents = true; + this.setStateWithData({ + currentlyResizing: { + id: column.id, + startX: pageX, + parentWidth: parentWidth + } + }, function () { + if (isTouch) { + document.addEventListener('touchmove', _this5.resizeColumnMoving); + document.addEventListener('touchcancel', _this5.resizeColumnEnd); + document.addEventListener('touchend', _this5.resizeColumnEnd); + } else { + document.addEventListener('mousemove', _this5.resizeColumnMoving); + document.addEventListener('mouseup', _this5.resizeColumnEnd); + document.addEventListener('mouseleave', _this5.resizeColumnEnd); + } + }); + } + }, { + key: 'resizeColumnMoving', + value: function resizeColumnMoving(event) { + event.stopPropagation(); + var onResizedChange = this.props.onResizedChange; + + var _getResolvedState4 = this.getResolvedState(), + resized = _getResolvedState4.resized, + currentlyResizing = _getResolvedState4.currentlyResizing; + + // Delete old value + + + var newResized = resized.filter(function (x) { + return x.id !== currentlyResizing.id; + }); + + var pageX = void 0; + + if (event.type === 'touchmove') { + pageX = event.changedTouches[0].pageX; + } else if (event.type === 'mousemove') { + pageX = event.pageX; + } + + // Set the min size to 10 to account for margin and border or else the + // group headers don't line up correctly + var newWidth = Math.max(currentlyResizing.parentWidth + pageX - currentlyResizing.startX, 11); + + newResized.push({ + id: currentlyResizing.id, + value: newWidth + }); + + this.setStateWithData({ + resized: newResized + }, function () { + return onResizedChange && onResizedChange(newResized, event); + }); + } + }, { + key: 'resizeColumnEnd', + value: function resizeColumnEnd(event) { + event.stopPropagation(); + var isTouch = event.type === 'touchend' || event.type === 'touchcancel'; + + if (isTouch) { + document.removeEventListener('touchmove', this.resizeColumnMoving); + document.removeEventListener('touchcancel', this.resizeColumnEnd); + document.removeEventListener('touchend', this.resizeColumnEnd); + } + + // If its a touch event clear the mouse one's as well because sometimes + // the mouseDown event gets called as well, but the mouseUp event doesn't + document.removeEventListener('mousemove', this.resizeColumnMoving); + document.removeEventListener('mouseup', this.resizeColumnEnd); + document.removeEventListener('mouseleave', this.resizeColumnEnd); + + // The touch events don't propagate up to the sorting's onMouseDown event so + // no need to prevent it from happening or else the first click after a touch + // event resize will not sort the column. + if (!isTouch) { + this.setStateWithData({ + skipNextSort: true, + currentlyResizing: false + }); + } + } + }]); + + return _class; + }(Base); +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/methods.js"],"names":["props","state","resolvedState","_","compactObject","newState","dataChanged","columns","pivotBy","data","resolveData","pivotIDKey","pivotValKey","subRowsKey","aggregatedKey","nestingLevelKey","originalKey","indexKey","groupedByPivotKey","SubComponent","hasHeaderGroups","forEach","column","columnsWithExpander","expanderColumn","find","col","expander","some","col2","makeDecoratedColumn","parentColumn","dcol","expanderDefaults","maxWidth","minWidth","accessor","id","accessorString","get","row","console","warn","Error","undefined","allDecoratedColumns","decorateAndAddToAll","decoratedColumn","push","decoratedColumns","map","d","visibleColumns","slice","allVisibleColumns","visibleSubColumns","filter","indexOf","getFirstDefined","show","length","pivotIndex","findIndex","pivot","pivotColumns","found","pivotID","PivotParentColumn","reduce","prev","current","PivotGroupHeader","Header","pivotColumnGroup","pivotDefaults","pivoted","splice","unshift","headerGroups","currentSpan","addHeader","concat","accessRow","i","level","resolvedData","aggregatingColumns","aggregate","aggregationValues","values","rows","groupRecursively","keys","groupedRows","Object","entries","groupBy","key","value","subRows","rowGroup","manual","sorted","filtered","defaultFilterMethod","sortMethodsByColumnID","sortMethod","sortedData","sortData","filterData","onFetchData","getResolvedState","filteredData","filteredSoFar","nextFilter","x","filterable","filterMethod","filterAll","orderByMethod","orderBy","sort","a","b","desc","defaultSortMethod","minRows","getStateOrProp","page","onPageChange","collapseOnPageChange","expanded","setStateWithData","newPageSize","onPageSizeChange","pageSize","currentRow","newPage","Math","floor","additive","skipNextSort","defaultSortDesc","firstSortDirection","prototype","hasOwnProperty","call","secondSortDirection","onSortedChange","newSorted","clone","isSortingDesc","isArray","existingIndex","existing","onFilteredChange","newFiltering","event","isTouch","stopPropagation","parentWidth","target","parentElement","getBoundingClientRect","width","pageX","changedTouches","trapEvents","currentlyResizing","startX","document","addEventListener","resizeColumnMoving","resizeColumnEnd","onResizedChange","resized","newResized","type","newWidth","max","removeEventListener","Base"],"mappings":"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","file":"methods.js","sourcesContent":["import React from 'react'\nimport _ from './utils'\n\nexport default Base =>\n  class extends Base {\n    getResolvedState (props, state) {\n      const resolvedState = {\n        ..._.compactObject(this.state),\n        ..._.compactObject(this.props),\n        ..._.compactObject(state),\n        ..._.compactObject(props),\n      }\n      return resolvedState\n    }\n\n    getDataModel (newState, dataChanged) {\n      const {\n        columns,\n        pivotBy = [],\n        data,\n        resolveData,\n        pivotIDKey,\n        pivotValKey,\n        subRowsKey,\n        aggregatedKey,\n        nestingLevelKey,\n        originalKey,\n        indexKey,\n        groupedByPivotKey,\n        SubComponent,\n      } = newState\n\n      // Determine Header Groups\n      let hasHeaderGroups = false\n      columns.forEach(column => {\n        if (column.columns) {\n          hasHeaderGroups = true\n        }\n      })\n\n      let columnsWithExpander = [...columns]\n\n      let expanderColumn = columns.find(\n        col => col.expander || (col.columns && col.columns.some(col2 => col2.expander))\n      )\n      // The actual expander might be in the columns field of a group column\n      if (expanderColumn && !expanderColumn.expander) {\n        expanderColumn = expanderColumn.columns.find(col => col.expander)\n      }\n\n      // If we have SubComponent's we need to make sure we have an expander column\n      if (SubComponent && !expanderColumn) {\n        expanderColumn = { expander: true }\n        columnsWithExpander = [expanderColumn, ...columnsWithExpander]\n      }\n\n      const makeDecoratedColumn = (column, parentColumn) => {\n        let dcol\n        if (column.expander) {\n          dcol = {\n            ...this.props.column,\n            ...this.props.expanderDefaults,\n            ...column,\n          }\n        } else {\n          dcol = {\n            ...this.props.column,\n            ...column,\n          }\n        }\n\n        // Ensure minWidth is not greater than maxWidth if set\n        if (dcol.maxWidth < dcol.minWidth) {\n          dcol.minWidth = dcol.maxWidth\n        }\n\n        if (parentColumn) {\n          dcol.parentColumn = parentColumn\n        }\n\n        // First check for string accessor\n        if (typeof dcol.accessor === 'string') {\n          dcol.id = dcol.id || dcol.accessor\n          const accessorString = dcol.accessor\n          dcol.accessor = row => _.get(row, accessorString)\n          return dcol\n        }\n\n        // Fall back to functional accessor (but require an ID)\n        if (dcol.accessor && !dcol.id) {\n          console.warn(dcol)\n          throw new Error(\n            'A column id is required if using a non-string accessor for column above.'\n          )\n        }\n\n        // Fall back to an undefined accessor\n        if (!dcol.accessor) {\n          dcol.accessor = () => undefined\n        }\n\n        return dcol\n      }\n\n      const allDecoratedColumns = []\n\n      // Decorate the columns\n      const decorateAndAddToAll = (column, parentColumn) => {\n        const decoratedColumn = makeDecoratedColumn(column, parentColumn)\n        allDecoratedColumns.push(decoratedColumn)\n        return decoratedColumn\n      }\n\n      const decoratedColumns = columnsWithExpander.map(column => {\n        if (column.columns) {\n          return {\n            ...column,\n            columns: column.columns.map(d => decorateAndAddToAll(d, column)),\n          }\n        }\n        return decorateAndAddToAll(column)\n      })\n\n      // Build the visible columns, headers and flat column list\n      let visibleColumns = decoratedColumns.slice()\n      let allVisibleColumns = []\n\n      visibleColumns = visibleColumns.map(column => {\n        if (column.columns) {\n          const visibleSubColumns = column.columns.filter(\n            d => (pivotBy.indexOf(d.id) > -1 ? false : _.getFirstDefined(d.show, true))\n          )\n          return {\n            ...column,\n            columns: visibleSubColumns,\n          }\n        }\n        return column\n      })\n\n      visibleColumns = visibleColumns.filter(\n        column =>\n          column.columns\n            ? column.columns.length\n            : pivotBy.indexOf(column.id) > -1\n              ? false\n              : _.getFirstDefined(column.show, true)\n      )\n\n      // Find any custom pivot location\n      const pivotIndex = visibleColumns.findIndex(col => col.pivot)\n\n      // Handle Pivot Columns\n      if (pivotBy.length) {\n        // Retrieve the pivot columns in the correct pivot order\n        const pivotColumns = []\n        pivotBy.forEach(pivotID => {\n          const found = allDecoratedColumns.find(d => d.id === pivotID)\n          if (found) {\n            pivotColumns.push(found)\n          }\n        })\n\n        const PivotParentColumn = pivotColumns.reduce(\n          (prev, current) => prev && prev === current.parentColumn && current.parentColumn,\n          pivotColumns[0].parentColumn\n        )\n\n        let PivotGroupHeader = hasHeaderGroups && PivotParentColumn.Header\n        PivotGroupHeader = PivotGroupHeader || (() => <strong>Pivoted</strong>)\n\n        let pivotColumnGroup = {\n          Header: PivotGroupHeader,\n          columns: pivotColumns.map(col => ({\n            ...this.props.pivotDefaults,\n            ...col,\n            pivoted: true,\n          })),\n        }\n\n        // Place the pivotColumns back into the visibleColumns\n        if (pivotIndex >= 0) {\n          pivotColumnGroup = {\n            ...visibleColumns[pivotIndex],\n            ...pivotColumnGroup,\n          }\n          visibleColumns.splice(pivotIndex, 1, pivotColumnGroup)\n        } else {\n          visibleColumns.unshift(pivotColumnGroup)\n        }\n      }\n\n      // Build Header Groups\n      const headerGroups = []\n      let currentSpan = []\n\n      // A convenience function to add a header and reset the currentSpan\n      const addHeader = (columns, column) => {\n        headerGroups.push({\n          ...this.props.column,\n          ...column,\n          columns,\n        })\n        currentSpan = []\n      }\n\n      // Build flast list of allVisibleColumns and HeaderGroups\n      visibleColumns.forEach(column => {\n        if (column.columns) {\n          allVisibleColumns = allVisibleColumns.concat(column.columns)\n          if (currentSpan.length > 0) {\n            addHeader(currentSpan)\n          }\n          addHeader(column.columns, column)\n          return\n        }\n        allVisibleColumns.push(column)\n        currentSpan.push(column)\n      })\n      if (hasHeaderGroups && currentSpan.length > 0) {\n        addHeader(currentSpan)\n      }\n\n      // Access the data\n      const accessRow = (d, i, level = 0) => {\n        const row = {\n          [originalKey]: d,\n          [indexKey]: i,\n          [subRowsKey]: d[subRowsKey],\n          [nestingLevelKey]: level,\n        }\n        allDecoratedColumns.forEach(column => {\n          if (column.expander) return\n          row[column.id] = column.accessor(d)\n        })\n        if (row[subRowsKey]) {\n          row[subRowsKey] = row[subRowsKey].map((d, i) => accessRow(d, i, level + 1))\n        }\n        return row\n      }\n\n      // // If the data hasn't changed, just use the cached data\n      let resolvedData = this.resolvedData\n      // If the data has changed, run the data resolver and cache the result\n      if (!this.resolvedData || dataChanged) {\n        resolvedData = resolveData(data)\n        this.resolvedData = resolvedData\n      }\n      // Use the resolved data\n      resolvedData = resolvedData.map((d, i) => accessRow(d, i))\n\n      // TODO: Make it possible to fabricate nested rows without pivoting\n      const aggregatingColumns = allVisibleColumns.filter(d => !d.expander && d.aggregate)\n\n      // If pivoting, recursively group the data\n      const aggregate = rows => {\n        const aggregationValues = {}\n        aggregatingColumns.forEach(column => {\n          const values = rows.map(d => d[column.id])\n          aggregationValues[column.id] = column.aggregate(values, rows)\n        })\n        return aggregationValues\n      }\n      if (pivotBy.length) {\n        const groupRecursively = (rows, keys, i = 0) => {\n          // This is the last level, just return the rows\n          if (i === keys.length) {\n            return rows\n          }\n          // Group the rows together for this level\n          let groupedRows = Object.entries(_.groupBy(rows, keys[i])).map(([key, value]) => ({\n            [pivotIDKey]: keys[i],\n            [pivotValKey]: key,\n            [keys[i]]: key,\n            [subRowsKey]: value,\n            [nestingLevelKey]: i,\n            [groupedByPivotKey]: true,\n          }))\n          // Recurse into the subRows\n          groupedRows = groupedRows.map(rowGroup => {\n            const subRows = groupRecursively(rowGroup[subRowsKey], keys, i + 1)\n            return {\n              ...rowGroup,\n              [subRowsKey]: subRows,\n              [aggregatedKey]: true,\n              ...aggregate(subRows),\n            }\n          })\n          return groupedRows\n        }\n        resolvedData = groupRecursively(resolvedData, pivotBy)\n      }\n\n      return {\n        ...newState,\n        resolvedData,\n        allVisibleColumns,\n        headerGroups,\n        allDecoratedColumns,\n        hasHeaderGroups,\n      }\n    }\n\n    getSortedData (resolvedState) {\n      const {\n        manual,\n        sorted,\n        filtered,\n        defaultFilterMethod,\n        resolvedData,\n        allVisibleColumns,\n        allDecoratedColumns,\n      } = resolvedState\n\n      const sortMethodsByColumnID = {}\n\n      allDecoratedColumns.filter(col => col.sortMethod).forEach(col => {\n        sortMethodsByColumnID[col.id] = col.sortMethod\n      })\n\n      // Resolve the data from either manual data or sorted data\n      return {\n        sortedData: manual\n          ? resolvedData\n          : this.sortData(\n            this.filterData(resolvedData, filtered, defaultFilterMethod, allVisibleColumns),\n            sorted,\n            sortMethodsByColumnID\n          ),\n      }\n    }\n\n    fireFetchData () {\n      this.props.onFetchData(this.getResolvedState(), this)\n    }\n\n    getPropOrState (key) {\n      return _.getFirstDefined(this.props[key], this.state[key])\n    }\n\n    getStateOrProp (key) {\n      return _.getFirstDefined(this.state[key], this.props[key])\n    }\n\n    filterData (data, filtered, defaultFilterMethod, allVisibleColumns) {\n      let filteredData = data\n\n      if (filtered.length) {\n        filteredData = filtered.reduce((filteredSoFar, nextFilter) => {\n          const column = allVisibleColumns.find(x => x.id === nextFilter.id)\n\n          // Don't filter hidden columns or columns that have had their filters disabled\n          if (!column || column.filterable === false) {\n            return filteredSoFar\n          }\n\n          const filterMethod = column.filterMethod || defaultFilterMethod\n\n          // If 'filterAll' is set to true, pass the entire dataset to the filter method\n          if (column.filterAll) {\n            return filterMethod(nextFilter, filteredSoFar, column)\n          }\n          return filteredSoFar.filter(row => filterMethod(nextFilter, row, column))\n        }, filteredData)\n\n        // Apply the filter to the subrows if we are pivoting, and then\n        // filter any rows without subcolumns because it would be strange to show\n        filteredData = filteredData\n          .map(row => {\n            if (!row[this.props.subRowsKey]) {\n              return row\n            }\n            return {\n              ...row,\n              [this.props.subRowsKey]: this.filterData(\n                row[this.props.subRowsKey],\n                filtered,\n                defaultFilterMethod,\n                allVisibleColumns\n              ),\n            }\n          })\n          .filter(row => {\n            if (!row[this.props.subRowsKey]) {\n              return true\n            }\n            return row[this.props.subRowsKey].length > 0\n          })\n      }\n\n      return filteredData\n    }\n\n    sortData (data, sorted, sortMethodsByColumnID = {}) {\n      if (!sorted.length) {\n        return data\n      }\n\n      const sortedData = (this.props.orderByMethod || _.orderBy)(\n        data,\n        sorted.map(sort => {\n          // Support custom sorting methods for each column\n          if (sortMethodsByColumnID[sort.id]) {\n            return (a, b) => sortMethodsByColumnID[sort.id](a[sort.id], b[sort.id], sort.desc)\n          }\n          return (a, b) => this.props.defaultSortMethod(a[sort.id], b[sort.id], sort.desc)\n        }),\n        sorted.map(d => !d.desc),\n        this.props.indexKey\n      )\n\n      sortedData.forEach(row => {\n        if (!row[this.props.subRowsKey]) {\n          return\n        }\n        row[this.props.subRowsKey] = this.sortData(\n          row[this.props.subRowsKey],\n          sorted,\n          sortMethodsByColumnID\n        )\n      })\n\n      return sortedData\n    }\n\n    getMinRows () {\n      return _.getFirstDefined(this.props.minRows, this.getStateOrProp('pageSize'))\n    }\n\n    // User actions\n    onPageChange (page) {\n      const { onPageChange, collapseOnPageChange } = this.props\n\n      const newState = { page }\n      if (collapseOnPageChange) {\n        newState.expanded = {}\n      }\n      this.setStateWithData(newState, () => onPageChange && onPageChange(page))\n    }\n\n    onPageSizeChange (newPageSize) {\n      const { onPageSizeChange } = this.props\n      const { pageSize, page } = this.getResolvedState()\n\n      // Normalize the page to display\n      const currentRow = pageSize * page\n      const newPage = Math.floor(currentRow / newPageSize)\n\n      this.setStateWithData(\n        {\n          pageSize: newPageSize,\n          page: newPage,\n        },\n        () => onPageSizeChange && onPageSizeChange(newPageSize, newPage)\n      )\n    }\n\n    sortColumn (column, additive) {\n      const { sorted, skipNextSort, defaultSortDesc } = this.getResolvedState()\n\n      const firstSortDirection = Object.prototype.hasOwnProperty.call(column, 'defaultSortDesc')\n        ? column.defaultSortDesc\n        : defaultSortDesc\n      const secondSortDirection = !firstSortDirection\n\n      // we can't stop event propagation from the column resize move handlers\n      // attached to the document because of react's synthetic events\n      // so we have to prevent the sort function from actually sorting\n      // if we click on the column resize element within a header.\n      if (skipNextSort) {\n        this.setStateWithData({\n          skipNextSort: false,\n        })\n        return\n      }\n\n      const { onSortedChange } = this.props\n\n      let newSorted = _.clone(sorted || []).map(d => {\n        d.desc = _.isSortingDesc(d)\n        return d\n      })\n      if (!_.isArray(column)) {\n        // Single-Sort\n        const existingIndex = newSorted.findIndex(d => d.id === column.id)\n        if (existingIndex > -1) {\n          const existing = newSorted[existingIndex]\n          if (existing.desc === secondSortDirection) {\n            if (additive) {\n              newSorted.splice(existingIndex, 1)\n            } else {\n              existing.desc = firstSortDirection\n              newSorted = [existing]\n            }\n          } else {\n            existing.desc = secondSortDirection\n            if (!additive) {\n              newSorted = [existing]\n            }\n          }\n        } else if (additive) {\n          newSorted.push({\n            id: column.id,\n            desc: firstSortDirection,\n          })\n        } else {\n          newSorted = [\n            {\n              id: column.id,\n              desc: firstSortDirection,\n            },\n          ]\n        }\n      } else {\n        // Multi-Sort\n        const existingIndex = newSorted.findIndex(d => d.id === column[0].id)\n        // Existing Sorted Column\n        if (existingIndex > -1) {\n          const existing = newSorted[existingIndex]\n          if (existing.desc === secondSortDirection) {\n            if (additive) {\n              newSorted.splice(existingIndex, column.length)\n            } else {\n              column.forEach((d, i) => {\n                newSorted[existingIndex + i].desc = firstSortDirection\n              })\n            }\n          } else {\n            column.forEach((d, i) => {\n              newSorted[existingIndex + i].desc = secondSortDirection\n            })\n          }\n          if (!additive) {\n            newSorted = newSorted.slice(existingIndex, column.length)\n          }\n          // New Sort Column\n        } else if (additive) {\n          newSorted = newSorted.concat(\n            column.map(d => ({\n              id: d.id,\n              desc: firstSortDirection,\n            }))\n          )\n        } else {\n          newSorted = column.map(d => ({\n            id: d.id,\n            desc: firstSortDirection,\n          }))\n        }\n      }\n\n      this.setStateWithData(\n        {\n          page: (!sorted.length && newSorted.length) || !additive ? 0 : this.state.page,\n          sorted: newSorted,\n        },\n        () => onSortedChange && onSortedChange(newSorted, column, additive)\n      )\n    }\n\n    filterColumn (column, value) {\n      const { filtered } = this.getResolvedState()\n      const { onFilteredChange } = this.props\n\n      // Remove old filter first if it exists\n      const newFiltering = (filtered || []).filter(x => x.id !== column.id)\n\n      if (value !== '') {\n        newFiltering.push({\n          id: column.id,\n          value,\n        })\n      }\n\n      this.setStateWithData(\n        {\n          filtered: newFiltering,\n        },\n        () => onFilteredChange && onFilteredChange(newFiltering, column, value)\n      )\n    }\n\n    resizeColumnStart (event, column, isTouch) {\n      event.stopPropagation()\n      const parentWidth = event.target.parentElement.getBoundingClientRect().width\n\n      let pageX\n      if (isTouch) {\n        pageX = event.changedTouches[0].pageX\n      } else {\n        pageX = event.pageX\n      }\n\n      this.trapEvents = true\n      this.setStateWithData(\n        {\n          currentlyResizing: {\n            id: column.id,\n            startX: pageX,\n            parentWidth,\n          },\n        },\n        () => {\n          if (isTouch) {\n            document.addEventListener('touchmove', this.resizeColumnMoving)\n            document.addEventListener('touchcancel', this.resizeColumnEnd)\n            document.addEventListener('touchend', this.resizeColumnEnd)\n          } else {\n            document.addEventListener('mousemove', this.resizeColumnMoving)\n            document.addEventListener('mouseup', this.resizeColumnEnd)\n            document.addEventListener('mouseleave', this.resizeColumnEnd)\n          }\n        }\n      )\n    }\n\n    resizeColumnMoving (event) {\n      event.stopPropagation()\n      const { onResizedChange } = this.props\n      const { resized, currentlyResizing } = this.getResolvedState()\n\n      // Delete old value\n      const newResized = resized.filter(x => x.id !== currentlyResizing.id)\n\n      let pageX\n\n      if (event.type === 'touchmove') {\n        pageX = event.changedTouches[0].pageX\n      } else if (event.type === 'mousemove') {\n        pageX = event.pageX\n      }\n\n      // Set the min size to 10 to account for margin and border or else the\n      // group headers don't line up correctly\n      const newWidth = Math.max(\n        currentlyResizing.parentWidth + pageX - currentlyResizing.startX,\n        11\n      )\n\n      newResized.push({\n        id: currentlyResizing.id,\n        value: newWidth,\n      })\n\n      this.setStateWithData(\n        {\n          resized: newResized,\n        },\n        () => onResizedChange && onResizedChange(newResized, event)\n      )\n    }\n\n    resizeColumnEnd (event) {\n      event.stopPropagation()\n      const isTouch = event.type === 'touchend' || event.type === 'touchcancel'\n\n      if (isTouch) {\n        document.removeEventListener('touchmove', this.resizeColumnMoving)\n        document.removeEventListener('touchcancel', this.resizeColumnEnd)\n        document.removeEventListener('touchend', this.resizeColumnEnd)\n      }\n\n      // If its a touch event clear the mouse one's as well because sometimes\n      // the mouseDown event gets called as well, but the mouseUp event doesn't\n      document.removeEventListener('mousemove', this.resizeColumnMoving)\n      document.removeEventListener('mouseup', this.resizeColumnEnd)\n      document.removeEventListener('mouseleave', this.resizeColumnEnd)\n\n      // The touch events don't propagate up to the sorting's onMouseDown event so\n      // no need to prevent it from happening or else the first click after a touch\n      // event resize will not sort the column.\n      if (!isTouch) {\n        this.setStateWithData({\n          skipNextSort: true,\n          currentlyResizing: false,\n        })\n      }\n    }\n  }\n"]} \ No newline at end of file diff --git a/lib/pagination.js b/lib/pagination.js new file mode 100644 index 0000000000..ff2d9ff994 --- /dev/null +++ b/lib/pagination.js @@ -0,0 +1,214 @@ +'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 _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 _classnames = require('classnames'); + +var _classnames2 = _interopRequireDefault(_classnames); + +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; } + +// +// import _ from './utils' + +var defaultButton = function defaultButton(props) { + return _react2.default.createElement( + 'button', + _extends({ type: 'button' }, props, { className: '-btn' }), + props.children + ); +}; + +var ReactTablePagination = function (_Component) { + _inherits(ReactTablePagination, _Component); + + function ReactTablePagination(props) { + _classCallCheck(this, ReactTablePagination); + + var _this = _possibleConstructorReturn(this, (ReactTablePagination.__proto__ || Object.getPrototypeOf(ReactTablePagination)).call(this)); + + _this.getSafePage = _this.getSafePage.bind(_this); + _this.changePage = _this.changePage.bind(_this); + _this.applyPage = _this.applyPage.bind(_this); + + _this.state = { + page: props.page + }; + return _this; + } + + _createClass(ReactTablePagination, [{ + key: 'componentWillReceiveProps', + value: function componentWillReceiveProps(nextProps) { + this.setState({ page: nextProps.page }); + } + }, { + key: 'getSafePage', + value: function getSafePage(page) { + if (Number.isNaN(page)) { + page = this.props.page; + } + return Math.min(Math.max(page, 0), this.props.pages - 1); + } + }, { + key: 'changePage', + value: function changePage(page) { + page = this.getSafePage(page); + this.setState({ page: page }); + if (this.props.page !== page) { + this.props.onPageChange(page); + } + } + }, { + key: 'applyPage', + value: function applyPage(e) { + if (e) { + e.preventDefault(); + } + var page = this.state.page; + this.changePage(page === '' ? this.props.page : page); + } + }, { + key: 'render', + value: function render() { + var _this2 = this; + + var _props = this.props, + pages = _props.pages, + page = _props.page, + showPageSizeOptions = _props.showPageSizeOptions, + pageSizeOptions = _props.pageSizeOptions, + pageSize = _props.pageSize, + showPageJump = _props.showPageJump, + canPrevious = _props.canPrevious, + canNext = _props.canNext, + onPageSizeChange = _props.onPageSizeChange, + className = _props.className, + _props$PreviousCompon = _props.PreviousComponent, + PreviousComponent = _props$PreviousCompon === undefined ? defaultButton : _props$PreviousCompon, + _props$NextComponent = _props.NextComponent, + NextComponent = _props$NextComponent === undefined ? defaultButton : _props$NextComponent; + + + return _react2.default.createElement( + 'div', + { className: (0, _classnames2.default)(className, '-pagination'), style: this.props.style }, + _react2.default.createElement( + 'div', + { className: '-previous' }, + _react2.default.createElement( + PreviousComponent, + { + onClick: function onClick() { + if (!canPrevious) return; + _this2.changePage(page - 1); + }, + disabled: !canPrevious + }, + this.props.previousText + ) + ), + _react2.default.createElement( + 'div', + { className: '-center' }, + _react2.default.createElement( + 'span', + { className: '-pageInfo' }, + this.props.pageText, + ' ', + showPageJump ? _react2.default.createElement( + 'div', + { className: '-pageJump' }, + _react2.default.createElement('input', { + type: this.state.page === '' ? 'text' : 'number', + onChange: function onChange(e) { + var val = e.target.value; + var page = val - 1; + if (val === '') { + return _this2.setState({ page: val }); + } + _this2.setState({ page: _this2.getSafePage(page) }); + }, + value: this.state.page === '' ? '' : this.state.page + 1, + onBlur: this.applyPage, + onKeyPress: function onKeyPress(e) { + if (e.which === 13 || e.keyCode === 13) { + _this2.applyPage(); + } + } + }) + ) : _react2.default.createElement( + 'span', + { className: '-currentPage' }, + page + 1 + ), + ' ', + this.props.ofText, + ' ', + _react2.default.createElement( + 'span', + { className: '-totalPages' }, + pages || 1 + ) + ), + showPageSizeOptions && _react2.default.createElement( + 'span', + { className: 'select-wrap -pageSizeOptions' }, + _react2.default.createElement( + 'select', + { onChange: function onChange(e) { + return onPageSizeChange(Number(e.target.value)); + }, value: pageSize }, + pageSizeOptions.map(function (option, i) { + return ( + // eslint-disable-next-line react/no-array-index-key + _react2.default.createElement( + 'option', + { key: i, value: option }, + option + ' ' + _this2.props.rowsText + ) + ); + }) + ) + ) + ), + _react2.default.createElement( + 'div', + { className: '-next' }, + _react2.default.createElement( + NextComponent, + { + onClick: function onClick() { + if (!canNext) return; + _this2.changePage(page + 1); + }, + disabled: !canNext + }, + this.props.nextText + ) + ) + ); + } + }]); + + return ReactTablePagination; +}(_react.Component); + +exports.default = ReactTablePagination; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/pagination.js"],"names":["defaultButton","props","children","ReactTablePagination","getSafePage","bind","changePage","applyPage","state","page","nextProps","setState","Number","isNaN","Math","min","max","pages","onPageChange","e","preventDefault","showPageSizeOptions","pageSizeOptions","pageSize","showPageJump","canPrevious","canNext","onPageSizeChange","className","PreviousComponent","NextComponent","style","previousText","pageText","val","target","value","which","keyCode","ofText","map","option","i","rowsText","nextText","Component"],"mappings":"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","file":"pagination.js","sourcesContent":["import React, { Component } from 'react'\nimport classnames from 'classnames'\n//\n// import _ from './utils'\n\nconst defaultButton = props => (\n  <button type=\"button\" {...props} className=\"-btn\">\n    {props.children}\n  </button>\n)\n\nexport default class ReactTablePagination extends Component {\n  constructor (props) {\n    super()\n\n    this.getSafePage = this.getSafePage.bind(this)\n    this.changePage = this.changePage.bind(this)\n    this.applyPage = this.applyPage.bind(this)\n\n    this.state = {\n      page: props.page,\n    }\n  }\n\n  componentWillReceiveProps (nextProps) {\n    this.setState({ page: nextProps.page })\n  }\n\n  getSafePage (page) {\n    if (Number.isNaN(page)) {\n      page = this.props.page\n    }\n    return Math.min(Math.max(page, 0), this.props.pages - 1)\n  }\n\n  changePage (page) {\n    page = this.getSafePage(page)\n    this.setState({ page })\n    if (this.props.page !== page) {\n      this.props.onPageChange(page)\n    }\n  }\n\n  applyPage (e) {\n    if (e) {\n      e.preventDefault()\n    }\n    const page = this.state.page\n    this.changePage(page === '' ? this.props.page : page)\n  }\n\n  render () {\n    const {\n      // Computed\n      pages,\n      // Props\n      page,\n      showPageSizeOptions,\n      pageSizeOptions,\n      pageSize,\n      showPageJump,\n      canPrevious,\n      canNext,\n      onPageSizeChange,\n      className,\n      PreviousComponent = defaultButton,\n      NextComponent = defaultButton,\n    } = this.props\n\n    return (\n      <div className={classnames(className, '-pagination')} style={this.props.style}>\n        <div className=\"-previous\">\n          <PreviousComponent\n            onClick={() => {\n              if (!canPrevious) return\n              this.changePage(page - 1)\n            }}\n            disabled={!canPrevious}\n          >\n            {this.props.previousText}\n          </PreviousComponent>\n        </div>\n        <div className=\"-center\">\n          <span className=\"-pageInfo\">\n            {this.props.pageText}{' '}\n            {showPageJump ? (\n              <div className=\"-pageJump\">\n                <input\n                  type={this.state.page === '' ? 'text' : 'number'}\n                  onChange={e => {\n                    const val = e.target.value\n                    const page = val - 1\n                    if (val === '') {\n                      return this.setState({ page: val })\n                    }\n                    this.setState({ page: this.getSafePage(page) })\n                  }}\n                  value={this.state.page === '' ? '' : this.state.page + 1}\n                  onBlur={this.applyPage}\n                  onKeyPress={e => {\n                    if (e.which === 13 || e.keyCode === 13) {\n                      this.applyPage()\n                    }\n                  }}\n                />\n              </div>\n            ) : (\n              <span className=\"-currentPage\">{page + 1}</span>\n            )}{' '}\n            {this.props.ofText} <span className=\"-totalPages\">{pages || 1}</span>\n          </span>\n          {showPageSizeOptions && (\n            <span className=\"select-wrap -pageSizeOptions\">\n              <select onChange={e => onPageSizeChange(Number(e.target.value))} value={pageSize}>\n                {pageSizeOptions.map((option, i) => (\n                  // eslint-disable-next-line react/no-array-index-key\n                  <option key={i} value={option}>\n                    {`${option} ${this.props.rowsText}`}\n                  </option>\n                ))}\n              </select>\n            </span>\n          )}\n        </div>\n        <div className=\"-next\">\n          <NextComponent\n            onClick={() => {\n              if (!canNext) return\n              this.changePage(page + 1)\n            }}\n            disabled={!canNext}\n          >\n            {this.props.nextText}\n          </NextComponent>\n        </div>\n      </div>\n    )\n  }\n}\n"]} \ No newline at end of file diff --git a/lib/propTypes.js b/lib/propTypes.js new file mode 100644 index 0000000000..9528f9d496 --- /dev/null +++ b/lib/propTypes.js @@ -0,0 +1,175 @@ +'use strict'; + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _propTypes = require('prop-types'); + +var _propTypes2 = _interopRequireDefault(_propTypes); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +exports.default = { + // General + data: _propTypes2.default.any, + loading: _propTypes2.default.bool, + showPagination: _propTypes2.default.bool, + showPaginationTop: _propTypes2.default.bool, + showPaginationBottom: _propTypes2.default.bool, + showPageSizeOptions: _propTypes2.default.bool, + pageSizeOptions: _propTypes2.default.array, + defaultPageSize: _propTypes2.default.number, + showPageJump: _propTypes2.default.bool, + collapseOnSortingChange: _propTypes2.default.bool, + collapseOnPageChange: _propTypes2.default.bool, + collapseOnDataChange: _propTypes2.default.bool, + freezeWhenExpanded: _propTypes2.default.bool, + sortable: _propTypes2.default.bool, + resizable: _propTypes2.default.bool, + filterable: _propTypes2.default.bool, + defaultSortDesc: _propTypes2.default.bool, + defaultSorted: _propTypes2.default.array, + defaultFiltered: _propTypes2.default.array, + defaultResized: _propTypes2.default.array, + defaultExpanded: _propTypes2.default.object, + defaultFilterMethod: _propTypes2.default.func, + defaultSortMethod: _propTypes2.default.func, + + // Controlled State Callbacks + onPageChange: _propTypes2.default.func, + onPageSizeChange: _propTypes2.default.func, + onSortedChange: _propTypes2.default.func, + onFilteredChange: _propTypes2.default.func, + onResizedChange: _propTypes2.default.func, + onExpandedChange: _propTypes2.default.func, + + // Pivoting + pivotBy: _propTypes2.default.array, + + // Key Constants + pivotValKey: _propTypes2.default.string, + pivotIDKey: _propTypes2.default.string, + subRowsKey: _propTypes2.default.string, + aggregatedKey: _propTypes2.default.string, + nestingLevelKey: _propTypes2.default.string, + originalKey: _propTypes2.default.string, + indexKey: _propTypes2.default.string, + groupedByPivotKey: _propTypes2.default.string, + + // Server-side Callbacks + onFetchData: _propTypes2.default.func, + + // Classes + className: _propTypes2.default.string, + style: _propTypes2.default.object, + + // Component decorators + getProps: _propTypes2.default.func, + getTableProps: _propTypes2.default.func, + getTheadGroupProps: _propTypes2.default.func, + getTheadGroupTrProps: _propTypes2.default.func, + getTheadGroupThProps: _propTypes2.default.func, + getTheadProps: _propTypes2.default.func, + getTheadTrProps: _propTypes2.default.func, + getTheadThProps: _propTypes2.default.func, + getTheadFilterProps: _propTypes2.default.func, + getTheadFilterTrProps: _propTypes2.default.func, + getTheadFilterThProps: _propTypes2.default.func, + getTbodyProps: _propTypes2.default.func, + getTrGroupProps: _propTypes2.default.func, + getTrProps: _propTypes2.default.func, + getTdProps: _propTypes2.default.func, + getTfootProps: _propTypes2.default.func, + getTfootTrProps: _propTypes2.default.func, + getTfootTdProps: _propTypes2.default.func, + getPaginationProps: _propTypes2.default.func, + getLoadingProps: _propTypes2.default.func, + getNoDataProps: _propTypes2.default.func, + getResizerProps: _propTypes2.default.func, + + // Global Column Defaults + columns: _propTypes2.default.arrayOf(_propTypes2.default.shape({ + // Renderers + Cell: _propTypes2.default.oneOfType([_propTypes2.default.element, _propTypes2.default.string, _propTypes2.default.func]), + Header: _propTypes2.default.oneOfType([_propTypes2.default.element, _propTypes2.default.string, _propTypes2.default.func]), + Footer: _propTypes2.default.oneOfType([_propTypes2.default.element, _propTypes2.default.string, _propTypes2.default.func]), + Aggregated: _propTypes2.default.oneOfType([_propTypes2.default.element, _propTypes2.default.string, _propTypes2.default.func]), + Pivot: _propTypes2.default.oneOfType([_propTypes2.default.element, _propTypes2.default.string, _propTypes2.default.func]), + PivotValue: _propTypes2.default.oneOfType([_propTypes2.default.element, _propTypes2.default.string, _propTypes2.default.func]), + Expander: _propTypes2.default.oneOfType([_propTypes2.default.element, _propTypes2.default.string, _propTypes2.default.func]), + Filter: _propTypes2.default.oneOfType([_propTypes2.default.element, _propTypes2.default.func]), + + // All Columns + sortable: _propTypes2.default.bool, // use table default + resizable: _propTypes2.default.bool, // use table default + filterable: _propTypes2.default.bool, // use table default + show: _propTypes2.default.bool, + minWidth: _propTypes2.default.number, + + // Cells only + className: _propTypes2.default.string, + style: _propTypes2.default.object, + getProps: _propTypes2.default.func, + + // Pivot only + aggregate: _propTypes2.default.func, + + // Headers only + headerClassName: _propTypes2.default.string, + headerStyle: _propTypes2.default.object, + getHeaderProps: _propTypes2.default.func, + + // Footers only + footerClassName: _propTypes2.default.string, + footerStyle: _propTypes2.default.object, + getFooterProps: _propTypes2.default.object, + filterMethod: _propTypes2.default.func, + filterAll: _propTypes2.default.bool, + sortMethod: _propTypes2.default.func + })), + + // Global Expander Column Defaults + expanderDefaults: _propTypes2.default.shape({ + sortable: _propTypes2.default.bool, + resizable: _propTypes2.default.bool, + filterable: _propTypes2.default.bool, + width: _propTypes2.default.number + }), + + pivotDefaults: _propTypes2.default.object, + + // Text + previousText: _propTypes2.default.node, + nextText: _propTypes2.default.node, + loadingText: _propTypes2.default.node, + noDataText: _propTypes2.default.node, + pageText: _propTypes2.default.node, + ofText: _propTypes2.default.node, + rowsText: _propTypes2.default.node, + + // Components + TableComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]), + TheadComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]), + TbodyComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]), + TrGroupComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]), + TrComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]), + ThComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]), + TdComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]), + TfootComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]), + FilterComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]), + ExpanderComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]), + PivotValueComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]), + AggregatedComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]), + // this is a computed default generated using + PivotComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]), + // the ExpanderComponent and PivotValueComponent at run-time in methods.js + PaginationComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]), + PreviousComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]), + NextComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]), + LoadingComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]), + NoDataComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]), + ResizerComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]), + PadRowComponent: _propTypes2.default.oneOfType([_propTypes2.default.func, _propTypes2.default.element]) +}; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/propTypes.js"],"names":["data","PropTypes","any","loading","bool","showPagination","showPaginationTop","showPaginationBottom","showPageSizeOptions","pageSizeOptions","array","defaultPageSize","number","showPageJump","collapseOnSortingChange","collapseOnPageChange","collapseOnDataChange","freezeWhenExpanded","sortable","resizable","filterable","defaultSortDesc","defaultSorted","defaultFiltered","defaultResized","defaultExpanded","object","defaultFilterMethod","func","defaultSortMethod","onPageChange","onPageSizeChange","onSortedChange","onFilteredChange","onResizedChange","onExpandedChange","pivotBy","pivotValKey","string","pivotIDKey","subRowsKey","aggregatedKey","nestingLevelKey","originalKey","indexKey","groupedByPivotKey","onFetchData","className","style","getProps","getTableProps","getTheadGroupProps","getTheadGroupTrProps","getTheadGroupThProps","getTheadProps","getTheadTrProps","getTheadThProps","getTheadFilterProps","getTheadFilterTrProps","getTheadFilterThProps","getTbodyProps","getTrGroupProps","getTrProps","getTdProps","getTfootProps","getTfootTrProps","getTfootTdProps","getPaginationProps","getLoadingProps","getNoDataProps","getResizerProps","columns","arrayOf","shape","Cell","oneOfType","element","Header","Footer","Aggregated","Pivot","PivotValue","Expander","Filter","show","minWidth","aggregate","headerClassName","headerStyle","getHeaderProps","footerClassName","footerStyle","getFooterProps","filterMethod","filterAll","sortMethod","expanderDefaults","width","pivotDefaults","previousText","node","nextText","loadingText","noDataText","pageText","ofText","rowsText","TableComponent","TheadComponent","TbodyComponent","TrGroupComponent","TrComponent","ThComponent","TdComponent","TfootComponent","FilterComponent","ExpanderComponent","PivotValueComponent","AggregatedComponent","PivotComponent","PaginationComponent","PreviousComponent","NextComponent","LoadingComponent","NoDataComponent","ResizerComponent","PadRowComponent"],"mappings":"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","file":"propTypes.js","sourcesContent":["import PropTypes from 'prop-types'\n\nexport default {\n  // General\n  data: PropTypes.any,\n  loading: PropTypes.bool,\n  showPagination: PropTypes.bool,\n  showPaginationTop: PropTypes.bool,\n  showPaginationBottom: PropTypes.bool,\n  showPageSizeOptions: PropTypes.bool,\n  pageSizeOptions: PropTypes.array,\n  defaultPageSize: PropTypes.number,\n  showPageJump: PropTypes.bool,\n  collapseOnSortingChange: PropTypes.bool,\n  collapseOnPageChange: PropTypes.bool,\n  collapseOnDataChange: PropTypes.bool,\n  freezeWhenExpanded: PropTypes.bool,\n  sortable: PropTypes.bool,\n  resizable: PropTypes.bool,\n  filterable: PropTypes.bool,\n  defaultSortDesc: PropTypes.bool,\n  defaultSorted: PropTypes.array,\n  defaultFiltered: PropTypes.array,\n  defaultResized: PropTypes.array,\n  defaultExpanded: PropTypes.object,\n  defaultFilterMethod: PropTypes.func,\n  defaultSortMethod: PropTypes.func,\n\n  // Controlled State Callbacks\n  onPageChange: PropTypes.func,\n  onPageSizeChange: PropTypes.func,\n  onSortedChange: PropTypes.func,\n  onFilteredChange: PropTypes.func,\n  onResizedChange: PropTypes.func,\n  onExpandedChange: PropTypes.func,\n\n  // Pivoting\n  pivotBy: PropTypes.array,\n\n  // Key Constants\n  pivotValKey: PropTypes.string,\n  pivotIDKey: PropTypes.string,\n  subRowsKey: PropTypes.string,\n  aggregatedKey: PropTypes.string,\n  nestingLevelKey: PropTypes.string,\n  originalKey: PropTypes.string,\n  indexKey: PropTypes.string,\n  groupedByPivotKey: PropTypes.string,\n\n  // Server-side Callbacks\n  onFetchData: PropTypes.func,\n\n  // Classes\n  className: PropTypes.string,\n  style: PropTypes.object,\n\n  // Component decorators\n  getProps: PropTypes.func,\n  getTableProps: PropTypes.func,\n  getTheadGroupProps: PropTypes.func,\n  getTheadGroupTrProps: PropTypes.func,\n  getTheadGroupThProps: PropTypes.func,\n  getTheadProps: PropTypes.func,\n  getTheadTrProps: PropTypes.func,\n  getTheadThProps: PropTypes.func,\n  getTheadFilterProps: PropTypes.func,\n  getTheadFilterTrProps: PropTypes.func,\n  getTheadFilterThProps: PropTypes.func,\n  getTbodyProps: PropTypes.func,\n  getTrGroupProps: PropTypes.func,\n  getTrProps: PropTypes.func,\n  getTdProps: PropTypes.func,\n  getTfootProps: PropTypes.func,\n  getTfootTrProps: PropTypes.func,\n  getTfootTdProps: PropTypes.func,\n  getPaginationProps: PropTypes.func,\n  getLoadingProps: PropTypes.func,\n  getNoDataProps: PropTypes.func,\n  getResizerProps: PropTypes.func,\n\n  // Global Column Defaults\n  columns: PropTypes.arrayOf(\n    PropTypes.shape({\n      // Renderers\n      Cell: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]),\n      Header: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]),\n      Footer: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]),\n      Aggregated: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]),\n      Pivot: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]),\n      PivotValue: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]),\n      Expander: PropTypes.oneOfType([PropTypes.element, PropTypes.string, PropTypes.func]),\n      Filter: PropTypes.oneOfType([PropTypes.element, PropTypes.func]),\n\n      // All Columns\n      sortable: PropTypes.bool, // use table default\n      resizable: PropTypes.bool, // use table default\n      filterable: PropTypes.bool, // use table default\n      show: PropTypes.bool,\n      minWidth: PropTypes.number,\n\n      // Cells only\n      className: PropTypes.string,\n      style: PropTypes.object,\n      getProps: PropTypes.func,\n\n      // Pivot only\n      aggregate: PropTypes.func,\n\n      // Headers only\n      headerClassName: PropTypes.string,\n      headerStyle: PropTypes.object,\n      getHeaderProps: PropTypes.func,\n\n      // Footers only\n      footerClassName: PropTypes.string,\n      footerStyle: PropTypes.object,\n      getFooterProps: PropTypes.object,\n      filterMethod: PropTypes.func,\n      filterAll: PropTypes.bool,\n      sortMethod: PropTypes.func,\n    })\n  ),\n\n  // Global Expander Column Defaults\n  expanderDefaults: PropTypes.shape({\n    sortable: PropTypes.bool,\n    resizable: PropTypes.bool,\n    filterable: PropTypes.bool,\n    width: PropTypes.number,\n  }),\n\n  pivotDefaults: PropTypes.object,\n\n  // Text\n  previousText: PropTypes.node,\n  nextText: PropTypes.node,\n  loadingText: PropTypes.node,\n  noDataText: PropTypes.node,\n  pageText: PropTypes.node,\n  ofText: PropTypes.node,\n  rowsText: PropTypes.node,\n\n  // Components\n  TableComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  TheadComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  TbodyComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  TrGroupComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  TrComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  ThComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  TdComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  TfootComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  FilterComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  ExpanderComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  PivotValueComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  AggregatedComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  // this is a computed default generated using\n  PivotComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  // the ExpanderComponent and PivotValueComponent at run-time in methods.js\n  PaginationComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  PreviousComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  NextComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  LoadingComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  NoDataComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  ResizerComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n  PadRowComponent: PropTypes.oneOfType([PropTypes.func, PropTypes.element]),\n}\n"]} \ No newline at end of file diff --git a/lib/utils.js b/lib/utils.js new file mode 100644 index 0000000000..77ec2213eb --- /dev/null +++ b/lib/utils.js @@ -0,0 +1,241 @@ +'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 _react = require('react'); + +var _react2 = _interopRequireDefault(_react); + +var _classnames = require('classnames'); + +var _classnames2 = _interopRequireDefault(_classnames); + +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; } + +// +exports.default = { + get: get, + set: set, + takeRight: takeRight, + last: last, + orderBy: orderBy, + range: range, + remove: remove, + clone: clone, + getFirstDefined: getFirstDefined, + sum: sum, + makeTemplateComponent: makeTemplateComponent, + groupBy: groupBy, + isArray: isArray, + splitProps: splitProps, + compactObject: compactObject, + isSortingDesc: isSortingDesc, + normalizeComponent: normalizeComponent, + asPx: asPx +}; + + +function get(obj, path, def) { + if (!path) { + return obj; + } + var pathObj = makePathArray(path); + var val = void 0; + try { + val = pathObj.reduce(function (current, pathPart) { + return current[pathPart]; + }, obj); + } catch (e) { + // continue regardless of error + } + return typeof val !== 'undefined' ? val : def; +} + +function set() { + var obj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var path = arguments[1]; + var value = arguments[2]; + + var keys = makePathArray(path); + var keyPart = void 0; + var cursor = obj; + while ((keyPart = keys.shift()) && keys.length) { + if (!cursor[keyPart]) { + cursor[keyPart] = {}; + } + cursor = cursor[keyPart]; + } + cursor[keyPart] = value; + return obj; +} + +function takeRight(arr, n) { + var start = n > arr.length ? 0 : arr.length - n; + return arr.slice(start); +} + +function last(arr) { + return arr[arr.length - 1]; +} + +function range(n) { + var arr = []; + for (var i = 0; i < n; i += 1) { + arr.push(n); + } + return arr; +} + +function orderBy(arr, funcs, dirs, indexKey) { + return arr.sort(function (rowA, rowB) { + for (var i = 0; i < funcs.length; i += 1) { + var comp = funcs[i]; + var desc = dirs[i] === false || dirs[i] === 'desc'; + var sortInt = comp(rowA, rowB); + if (sortInt) { + return desc ? -sortInt : sortInt; + } + } + // Use the row index for tie breakers + return dirs[0] ? rowA[indexKey] - rowB[indexKey] : rowB[indexKey] - rowA[indexKey]; + }); +} + +function remove(a, b) { + return a.filter(function (o, i) { + var r = b(o); + if (r) { + a.splice(i, 1); + return true; + } + return false; + }); +} + +function clone(a) { + try { + return JSON.parse(JSON.stringify(a, function (key, value) { + if (typeof value === 'function') { + return value.toString(); + } + return value; + })); + } catch (e) { + return a; + } +} + +function getFirstDefined() { + for (var i = 0; i < arguments.length; i += 1) { + if (typeof (arguments.length <= i ? undefined : arguments[i]) !== 'undefined') { + return arguments.length <= i ? undefined : arguments[i]; + } + } +} + +function sum(arr) { + return arr.reduce(function (a, b) { + return a + b; + }, 0); +} + +function makeTemplateComponent(compClass, displayName) { + if (!displayName) { + throw new Error('No displayName found for template component:', compClass); + } + var cmp = function cmp(_ref) { + var children = _ref.children, + className = _ref.className, + rest = _objectWithoutProperties(_ref, ['children', 'className']); + + return _react2.default.createElement( + 'div', + _extends({ className: (0, _classnames2.default)(compClass, className) }, rest), + children + ); + }; + cmp.displayName = displayName; + return cmp; +} + +function groupBy(xs, key) { + return xs.reduce(function (rv, x, i) { + var resKey = typeof key === 'function' ? key(x, i) : x[key]; + rv[resKey] = isArray(rv[resKey]) ? rv[resKey] : []; + rv[resKey].push(x); + return rv; + }, {}); +} + +function asPx(value) { + value = Number(value); + return Number.isNaN(value) ? null : value + 'px'; +} + +function isArray(a) { + return Array.isArray(a); +} + +// ######################################################################## +// Non-exported Helpers +// ######################################################################## + +function makePathArray(obj) { + return flattenDeep(obj).join('.').replace(/\[/g, '.').replace(/\]/g, '').split('.'); +} + +function flattenDeep(arr) { + var newArr = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : []; + + if (!isArray(arr)) { + newArr.push(arr); + } else { + for (var i = 0; i < arr.length; i += 1) { + flattenDeep(arr[i], newArr); + } + } + return newArr; +} + +function splitProps(_ref2) { + var className = _ref2.className, + style = _ref2.style, + rest = _objectWithoutProperties(_ref2, ['className', 'style']); + + return { + className: className, + style: style, + rest: rest || {} + }; +} + +function compactObject(obj) { + var newObj = {}; + if (obj) { + Object.keys(obj).map(function (key) { + if (Object.prototype.hasOwnProperty.call(obj, key) && obj[key] !== undefined && typeof obj[key] !== 'undefined') { + newObj[key] = obj[key]; + } + return true; + }); + } + return newObj; +} + +function isSortingDesc(d) { + return !!(d.sort === 'desc' || d.desc === true || d.asc === false); +} + +function normalizeComponent(Comp) { + var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var fallback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Comp; + + return typeof Comp === 'function' ? Object.getPrototypeOf(Comp).isReactComponent ? _react2.default.createElement(Comp, params) : Comp(params) : fallback; +} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/utils.js"],"names":["get","set","takeRight","last","orderBy","range","remove","clone","getFirstDefined","sum","makeTemplateComponent","groupBy","isArray","splitProps","compactObject","isSortingDesc","normalizeComponent","asPx","obj","path","def","pathObj","makePathArray","val","reduce","current","pathPart","e","value","keys","keyPart","cursor","shift","length","arr","n","start","slice","i","push","funcs","dirs","indexKey","sort","rowA","rowB","comp","desc","sortInt","a","b","filter","o","r","splice","JSON","parse","stringify","key","toString","compClass","displayName","Error","cmp","children","className","rest","xs","rv","x","resKey","Number","isNaN","Array","flattenDeep","join","replace","split","newArr","style","newObj","Object","map","prototype","hasOwnProperty","call","undefined","d","asc","Comp","params","fallback","getPrototypeOf","isReactComponent"],"mappings":"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","file":"utils.js","sourcesContent":["import React from 'react'\nimport classnames from 'classnames'\n//\nexport default {\n  get,\n  set,\n  takeRight,\n  last,\n  orderBy,\n  range,\n  remove,\n  clone,\n  getFirstDefined,\n  sum,\n  makeTemplateComponent,\n  groupBy,\n  isArray,\n  splitProps,\n  compactObject,\n  isSortingDesc,\n  normalizeComponent,\n  asPx,\n}\n\nfunction get (obj, path, def) {\n  if (!path) {\n    return obj\n  }\n  const pathObj = makePathArray(path)\n  let val\n  try {\n    val = pathObj.reduce((current, pathPart) => current[pathPart], obj)\n  } catch (e) {\n    // continue regardless of error\n  }\n  return typeof val !== 'undefined' ? val : def\n}\n\nfunction set (obj = {}, path, value) {\n  const keys = makePathArray(path)\n  let keyPart\n  let cursor = obj\n  while ((keyPart = keys.shift()) && keys.length) {\n    if (!cursor[keyPart]) {\n      cursor[keyPart] = {}\n    }\n    cursor = cursor[keyPart]\n  }\n  cursor[keyPart] = value\n  return obj\n}\n\nfunction takeRight (arr, n) {\n  const start = n > arr.length ? 0 : arr.length - n\n  return arr.slice(start)\n}\n\nfunction last (arr) {\n  return arr[arr.length - 1]\n}\n\nfunction range (n) {\n  const arr = []\n  for (let i = 0; i < n; i += 1) {\n    arr.push(n)\n  }\n  return arr\n}\n\nfunction orderBy (arr, funcs, dirs, indexKey) {\n  return arr.sort((rowA, rowB) => {\n    for (let i = 0; i < funcs.length; i += 1) {\n      const comp = funcs[i]\n      const desc = dirs[i] === false || dirs[i] === 'desc'\n      const sortInt = comp(rowA, rowB)\n      if (sortInt) {\n        return desc ? -sortInt : sortInt\n      }\n    }\n    // Use the row index for tie breakers\n    return dirs[0] ? rowA[indexKey] - rowB[indexKey] : rowB[indexKey] - rowA[indexKey]\n  })\n}\n\nfunction remove (a, b) {\n  return a.filter((o, i) => {\n    const r = b(o)\n    if (r) {\n      a.splice(i, 1)\n      return true\n    }\n    return false\n  })\n}\n\nfunction clone (a) {\n  try {\n    return JSON.parse(\n      JSON.stringify(a, (key, value) => {\n        if (typeof value === 'function') {\n          return value.toString()\n        }\n        return value\n      })\n    )\n  } catch (e) {\n    return a\n  }\n}\n\nfunction getFirstDefined (...args) {\n  for (let i = 0; i < args.length; i += 1) {\n    if (typeof args[i] !== 'undefined') {\n      return args[i]\n    }\n  }\n}\n\nfunction sum (arr) {\n  return arr.reduce((a, b) => a + b, 0)\n}\n\nfunction makeTemplateComponent (compClass, displayName) {\n  if (!displayName) {\n    throw new Error('No displayName found for template component:', compClass)\n  }\n  const cmp = ({ children, className, ...rest }) => (\n    <div className={classnames(compClass, className)} {...rest}>\n      {children}\n    </div>\n  )\n  cmp.displayName = displayName\n  return cmp\n}\n\nfunction groupBy (xs, key) {\n  return xs.reduce((rv, x, i) => {\n    const resKey = typeof key === 'function' ? key(x, i) : x[key]\n    rv[resKey] = isArray(rv[resKey]) ? rv[resKey] : []\n    rv[resKey].push(x)\n    return rv\n  }, {})\n}\n\nfunction asPx (value) {\n  value = Number(value)\n  return Number.isNaN(value) ? null : `${value}px`\n}\n\nfunction isArray (a) {\n  return Array.isArray(a)\n}\n\n// ########################################################################\n// Non-exported Helpers\n// ########################################################################\n\nfunction makePathArray (obj) {\n  return flattenDeep(obj)\n    .join('.')\n    .replace(/\\[/g, '.')\n    .replace(/\\]/g, '')\n    .split('.')\n}\n\nfunction flattenDeep (arr, newArr = []) {\n  if (!isArray(arr)) {\n    newArr.push(arr)\n  } else {\n    for (let i = 0; i < arr.length; i += 1) {\n      flattenDeep(arr[i], newArr)\n    }\n  }\n  return newArr\n}\n\nfunction splitProps ({ className, style, ...rest }) {\n  return {\n    className,\n    style,\n    rest: rest || {},\n  }\n}\n\nfunction compactObject (obj) {\n  const newObj = {}\n  if (obj) {\n    Object.keys(obj).map(key => {\n      if (\n        Object.prototype.hasOwnProperty.call(obj, key) &&\n        obj[key] !== undefined &&\n        typeof obj[key] !== 'undefined'\n      ) {\n        newObj[key] = obj[key]\n      }\n      return true\n    })\n  }\n  return newObj\n}\n\nfunction isSortingDesc (d) {\n  return !!(d.sort === 'desc' || d.desc === true || d.asc === false)\n}\n\nfunction normalizeComponent (Comp, params = {}, fallback = Comp) {\n  return typeof Comp === 'function' ? (\n    Object.getPrototypeOf(Comp).isReactComponent ? (\n      <Comp {...params} />\n    ) : (\n      Comp(params)\n    )\n  ) : (\n    fallback\n  )\n}\n"]} \ No newline at end of file