v7.0.0-alpha.0

Merge branch 'master' of https://github.com/react-tools/react-table
Update README.md
2026-08-19 08:20:30 +00:00 · 2019-02-04 18:56:10 -07:00 · 2019-02-01 09:36:17 -07:00 · 2019-02-01 09:36:13 -07:00 · 2019-02-01 09:01:33 -07:00 · 2019-02-01 08:56:40 -07:00
44 changed files with 12798 additions and 6198 deletions
@@ -0,0 +1,3 @@
+module.exports = {
+  extends: 'react-tools',
+}
@@ -0,0 +1 @@
+* text=auto
@@ -0,0 +1,46 @@
+---
+name: Bug report
+about: Create a report to help us improve
+
+---
+
+# Using v6?
+
+v6 is now considered feature complete to its current abilities and limitations. We are not actively working to fix any issues for v6 any more. We will, however, merge any non-breaking pull requests submitted to fix anything in v6.
+
+# Using v7?
+
+Thanks for using the alpha version of React Table v7! We're very excited about it.
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Codesandbox!**
+Use a new [react-table codesandbox](https://codesandbox.io/s/m5lxzzpz69) to reproduce the issue.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. iOS]
+ - Browser [e.g. chrome, safari]
+ - Version [e.g. 22]
+
+**Smartphone (please complete the following information):**
+ - Device: [e.g. iPhone6]
+ - OS: [e.g. iOS8.1]
+ - Browser [e.g. stock browser, safari]
+ - Version [e.g. 22]
+
+**Additional context**
+Add any other context about the problem here.
@@ -0,0 +1,9 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+
+---
+
+# STOP
+
+We do not track feature requests through Github. Please use the [Spectrum React Table Forum](https://spectrum.chat/react-table) to talk about new ideas and features.
@@ -0,0 +1,11 @@
+---
+name: Questions, Support & Help
+about: Looking for help? Need a question answered?
+
+---
+
+# STOP
+
+We do not use Github to track general support. Please use our public support forum at https://spectrum.chat/react-table.
+
+NOTE: If a support/help/question issue is opened, it will be closed immediately and be redirected to the forum. Thanks for helping us keep our issues clean and productive!
@@ -1,6 +1,11 @@
 node_modules/
 lib/
+es/
+docs/build
 react-table.js
+react-table.min.js
 react-table.css
 *.log
-example/dist/
+.idea
+.DS_Store
+.history
@@ -0,0 +1,173 @@
+## 6.8.6
+
+#### Fixes & Optimizations
+
+* Since `resolveData` is now capable of materializing data on it's own, the `data` prop is no longer required as a prop-type.
+
+## 6.8.4
+
+#### Fixes & Optimizations
+
+* Only run `resolveData` prop when `data` prop has changed, not any others.
+
+## 6.8.3
+
+#### Fixes & Optimizations
+
+* Allow the `resolveData` prop to alter or materialize new data when the `data` prop changes.
+
+## 6.8.1
+
+#### Fixes & Optimizations
+
+* Updated eslint and code formatting
+
+## 6.7.5
+
+#### Fixes & Optimizations
+
+* Now passes `column` to `getResizerProps` (#667)
+* NOTE: `getResizerProps` is now only called if the column is resizable
+* Fixes the `className` ordering in defaultProps for ThComponent (#673)
+* NOTE: user supplied classNames now come at the end so they can extend the defaults
+
+## 6.7.4
+
+#### Fixes & Optimizations
+
+* Fix Prop types for columns
+
+## 6.7.3
+
+#### Fixes & Optimizations
+
+* Fix the rest of the proptypes
+
+## 6.7.2
+
+#### Fixes & Optimizations
+
+* `getPropTypes` proptype check
+
+## 6.7.1
+
+#### Fixes & Optimizations
+
+* `eslint-config` moved to dev deps
+
+## 6.7.0
+
+## 6.7.0-alpha-0
+
+#### New Features
+
+* Expose page/pageSize to rows/cells
+* Supply sort direction to custom sort methods
+
+#### Fixes & Optimizations
+
+* README updates
+* Linter cleanup
+* Added PropTypes node module
+* Deps, linting and style upgrades
+
+## 6.6.0
+
+#### Fixes & Optimizations
+
+* moved repo to react-tools
+* Doc examples moved to codesandbox.io
+* README updates
+* CSS refacting for rt-tfoot to match rt-thead
+* CSS more specific for input and select
+
+## 6.5.3
+
+#### Fixes & Optimizations
+
+* `onClick` proxying and eslint
+
+## 6.5.2
+
+#### New Features
+
+* Provide onClick handleOriginal function - #406
+
+#### Fixes & Optimizations
+
+* README updates
+* `makePathArray` in utils - #326
+* Various fixes: #294, #376, #398, #415,
+
+## 6.5.1
+
+#### Fixes & Optimizations
+
+* `defaultExpanded` now works correctly - #372
+* `column.getProps().rest` props are now applied correctly
+* `makeTemplateComponent` now supports `displayName` - #289
+
+## 6.5.0
+
+##### New Features
+
+* `column.filterAll` - defaults to `false`, but when set to `true` will provide the entire array of rows to `filterMethod` as opposed to one row at a time. This allows for more fine-grained filtering using any method you can dream up. See the [Custom Filtering example](https://react-table.js.org/#/story/custom-filtering) for more info.
+
+## 6.4.0
+
+##### New Features
+
+* `PadRowComponent` - the content rendered inside of a padding row. Defaults to a react component that renders `&nbsp;`
+
+## 6.3.0
+
+##### New Features
+
+* `defaultSortDesc` - allows you to set the default sorting direction for all columns to descending.
+* `column.defaultSortDesc` - allows you to set the default sorting direction for a specific column. Falls back to the global `defaultSortDesc` when not set at all.
+
+## 6.0.0
+
+##### New Features
+
+* New Renderers:
+  * `Aggregated` - Custom renderer for aggregated cells
+  * `Pivot` - Custom renderer for Pivoted Cells (utilizes `Expander` and `PivotValue`)
+  * `PivotValue` - Custom renderer for Pivot cell values (deprecates the undocumented `pivotRender` option)
+  * `Expander` - Custom renderer for Pivot cell Expander
+* Added custom sorting methods per table via `defaultSortMethod` and per column via `column.sortMethod`
+* Pivot columns are now visibly separate and sorted/filtered independently.
+* Added `column.resizable` to override global table `resizable` option for specific columns.
+* Added `column.sortable` to override global table `sortable` option for specific columns.
+* Added `column.filterable` to override global table `filterable` option for specific columns.
+* Added `defaultExpanded` table option.
+* All callbacks can now be utilized without needing to hoist and manage the piece of state they export. That is what their prop counterparts are for, so now the corresponding prop is used instead of the callback to detect a "fully controlled" state.
+* Prevent transitions while column resizing for a smoother resize effect.
+* Disable text selection while resizing columns.
+
+##### Breaking API Changes
+
+* New Renderers:
+  * `Cell` - deprecates and replaces `render`
+  * `Header` - deprecates and replaces `header`
+  * `Footer` - deprecates and replaces `footer`
+  * `Filter`- deprecates and replaces `filterRender`
+* Callbacks now provide the destination state as the primary parameter(s). This makes hoisting and controlling the state in redux or component state much easier. eg.
+  * `onSorting` no longer requires you to build your own toggle logic
+  * `onResize` no longer requires you to build your own resize logic
+* Renamed `onChange` callback -> `onFetchData` which will always fire when a new data model needs to be fetched (or if not using `manual`, when new data is materialized internally).
+* Renamed `filtering` -> `filtered`
+* Renamed `sorting` -> `sorted`
+* Renamed `expandedRows` -> `expanded`
+* Renamed `resizing` -> `resized`
+* Renamed `defaultResizing` -> `defaultResized`
+* Renamed `defaultFiltering` -> `defaultFiltered`
+* Renamed `defaultSorting` -> `defaultSorted`
+* Renamed `onSortingChange` -> `onSortedChange`
+* Renamed `onFilteringChange` -> `onFilteredChange`
+* Renamed `onResize` -> `onResizedChange`
+* Renamed `onExpandRow` -> `onExpandedChange`
+* Renamed `showFilters` -> `filterable`
+* Renamed `hideFilter` -> `filterable` (Column option. Note the true/false value is now flipped.)
+* `cellInfo.row` and `rowInfo.row` now reference the materialize data for the table. To reference the original row, use `cellInfo.original` and `rowInfo.original`
+* Removed `pivotRender` column option. You can now control how the value is displayed by overriding the `PivotValueComponent` or the individual column's `PivotValue` renderer. See [Pivoting Options Story](https://react-table.js.org/?selectedKind=2.%20Demos&selectedStory=Pivoting%20Options&full=0&down=1&left=1&panelRight=0&downPanel=kadirahq%2Fstorybook-addon-actions%2Factions-panel) for a reference on how to customize pivot column rendering.
@@ -1,308 +1,165 @@
-<div align="center">
-  <a href="https://github.com/tannerlinsley/react-table"><img src="https://github.com/tannerlinsley/react-table/raw/master/media/Banner.png" alt="React Table Logo" style="width:450px;"/></a>
-  <br />
-  <br />
-  
-</div>
+# React Table

-# react-table
-A fast, lightweight, opinionated table and datagrid built on React
+Hooks for building **lightweight, fast and extendable datagrids** for React

-[![Build Status](https://travis-ci.org/tannerlinsley/react-table.svg?branch=master)](https://travis-ci.org/tannerlinsley/react-table) [![npm](https://img.shields.io/npm/dm/react-table.svg)]() [![react-table on Slack](https://img.shields.io/badge/slack-react--table-blue.svg)](https://react-table-slack.herokuapp.com/) [![GitHub stars](https://img.shields.io/github/stars/tannerlinsley/react-table.svg?style=social&label=Star)]() [![Twitter Follow](https://img.shields.io/twitter/follow/tannerlinsley.svg?style=social&label=Follow)](https://twitter.com/tannerlinsley)
+<a href="https://travis-ci.org/tannerlinsley/react-table" target="\_parent">
+  <img alt="" src="https://travis-ci.org/tannerlinsley/react-table.svg?branch=master" />
+</a>
+<a href="https://npmjs.com/package/react-table" target="\_parent">
+  <img alt="" src="https://img.shields.io/npm/dm/react-table.svg" />
+</a>
+<a href="https://spectrum.chat/react-table">
+  <img alt="Join the community on Spectrum" src="https://withspectrum.github.io/badge/badge.svg" />
+</a>
+<a href="https://github.com/tannerlinsley/react-table" target="\_parent">
+  <img alt="" src="https://img.shields.io/github/stars/tannerlinsley/react-table.svg?style=social&label=Star" />
+</a>
+<a href="https://twitter.com/tannerlinsley" target="\_parent">
+  <img alt="" src="https://img.shields.io/twitter/follow/tannerlinsley.svg?style=social&label=Follow" />
+</a>
+
+<br />
+<br />
+
+⚠️ Version 7 is under active development and is currently in an alpha state. If you are looking for [React Table v6, click here](https://github.com/tannerlinsley/react-table/tree/v6)

 ## Features

- Lightweight at 4kb (and just 2kb more for styles)
- Fully customizable JSX and callbacks for everything
- Supports both Client-side & Server-side pagination and sorting
- Minimal design & easily themeable
- ["Why I wrote React Table and the problems it has solved for Nozzle.io"](https://medium.com/@tannerlinsley/why-i-wrote-react-table-and-the-problems-it-has-solved-for-nozzle-others-445c4e93d4a8#.axza4ixba) by Tanner Linsley
+- Lightweight
+- Headless (Fully customizable)
+- Client-side & Server-side pagination
+- Multi-sort
+- Filters
+- Pivoting & Aggregation
+- Fully controllable
+- Extensible
+- <a href="https://medium.com/@tannerlinsley/why-i-wrote-react-table-and-the-problems-it-has-solved-for-nozzle-others-445c4e93d4a8#.axza4ixba" target="\_parent">"Why I wrote React Table and the problems it has solved for Nozzle.io"</a> by Tanner Linsley

-## [Demo](http://react-table.zabapps.com)
+## Versions
+
+- This documentation is for version 7 of react-table.
+- [View the Changelog](https://github.com/tannerlinsley/react-table/blob/master/CHANGELOG.md)
+- Previous versions:
+  - [6.x.x Readme](https://github.com/tannerlinsley/react-table/tree/v6/)
+  - [5.x.x Readme](https://github.com/tannerlinsley/react-table/blob/ad7d31cd3978eb45da7c6194dbab93c1e9a8594d/README.md)
+
+## Sponsors
+
+**React Table v7** is mostly planned and I (@tannerlinsley) am looking for Patreon support to make it a reality. It will require a decent time commitment on my part to not only implement it, but also help people migrate and continue to maintain it. If you would like to contribute to my Patreon goal for v7 and beyond, [visit my Patreon and help me out!](https://patreon.com/tannerlinsley).
+
+<table>
+  <tbody>
+    <tr>
+      <td align="center" valign="middle">
+        <a href="https://patreon.com/tannerlinsley" target="_blank">
+          <img src="https://raw.githubusercontent.com/tannerlinsley/files/master/images/patreon/platinum.png">
+        </a>
+      </td>
+      <td align="center" valign="middle">
+        <a href="https://tryretool.com/?utm_source=sponsor&utm_campaign=react_table" target="_blank">
+          <img src="https://raw.githubusercontent.com/tannerlinsley/files/master/images/patreon/sponsor-retool.png">
+        </a>
+      </td>
+    </tr>
+  </tbody>
+</table>
+
+<table>
+  <tbody>
+    <tr>
+      <td align="center" valign="middle">
+        <a href="https://patreon.com/tannerlinsley" target="_blank">
+          <img src="https://raw.githubusercontent.com/tannerlinsley/files/master/images/patreon/gold.png">
+        </a>
+      </td>
+      <td align="center" valign="middle">
+        <a href="https://nozzle.io" target="_blank">
+          <img width="300" src="https://nozzle.io/img/logo-blue.png">
+        </a>
+      </td>
+      <td align="center" valign="middle">
+        <a href="https://tryretool.com/?utm_source=sponsor&utm_campaign=react_table" target="_blank">
+          <img src="https://raw.githubusercontent.com/tannerlinsley/files/master/images/patreon/gold-placeholder.png">
+        </a>
+      </td>
+    </tr>
+  </tbody>
+</table>
+
+<table>
+  <tbody>
+    <tr>
+      <td align="center" valign="middle">
+        <a href="https://patreon.com/tannerlinsley" target="_blank">
+          <img src="https://raw.githubusercontent.com/tannerlinsley/files/master/images/patreon/silver.png">
+        </a>
+      </td>
+      <td align="center" valign="middle">
+        <a href="https://tryretool.com/?utm_source=sponsor&utm_campaign=react_table" target="_blank">
+          <img src="https://raw.githubusercontent.com/tannerlinsley/files/master/images/patreon/silver-placeholder.png">
+        </a>
+      </td>
+      <td align="center" valign="middle">
+        <a href="https://tryretool.com/?utm_source=sponsor&utm_campaign=react_table" target="_blank">
+          <img src="https://raw.githubusercontent.com/tannerlinsley/files/master/images/patreon/silver-placeholder.png">
+        </a>
+      </td>
+      <td align="center" valign="middle">
+        <a href="https://tryretool.com/?utm_source=sponsor&utm_campaign=react_table" target="_blank">
+          <img src="https://raw.githubusercontent.com/tannerlinsley/files/master/images/patreon/silver-placeholder.png">
+        </a>
+      </td>
+    </tr>
+  </tbody>
+</table>

 ## Table of Contents
- [Installation](#nstallation)
- [Example](#example)
- [Data](#data)
- [Default Props](#default-props)
- [Columns](#columns)
- [Styles](#styles)
- [Header Groups](#header-groups)
- [Server-side Data](#server-side-data)
- [Multi-sort](#multi-sort)
- [Component Overrides](#component-overrides)

-<a name="installation"></a>
+- [Installation](#installation)
+- [Example](#example)
+- [Contributing](#contributing)
+
 ## Installation
+
+1.  Install React Table as a dependency
+
 ```bash
+# Yarn
+$ yarn add react-table
+
+# NPM
 $ npm install react-table
 ```

-<a name="example"></a>
-## Example
-```javascript
-import ReactTable from 'react-table'
-
-const data = [{
-  name: 'Tanner Linsley',
-  age: 26,
-  friend: {
-    name: 'Jason Maurer',
-    age: 23,
-  }
-},{
-  ...
-}]
-
-const columns = [{
-  header: 'Name',
-  accessor: 'name' // String-based value accessors !
-}, {
-  header: 'Age',
-  accessor: 'age',
-  render: props => <span className='number'>props.value</span> // Custom cell components!
-}, {
-  header: 'Friend Name',
-  accessor: d => d.friend.name // Custom value accessors!
-}, {
-  header: props => <span>Friend Age</span>, // Custom header components!
-  accessor: 'friend.age'
-}]
-
-<ReactTable
-  data={data}
-  columns={columns}
-/>
-```
-
-<a name="data"></a>
-## Data
-Simply pass the `data` prop anything that resembles an array or object. Client-side filtering and pagination is built in, and your table will update gracefully as you change any props. [Server-side data](#server-side-data) is also supported!
-
-
-<a name="default-props"></a>
-## Default Props
-These are the default props for the main react component `<ReactTable />`
-```javascript
-{
-  // General
-  loading: false, // Whether to show the loading overlay or not
-  pageSize: 20, // The default page size (this can be changed by the user if `showPageSizeOptions` is enabled)
-  minRows: 0, // Ensure this many rows are always rendered, regardless of rows on page
-  showPagination: true, // Shows or hides the pagination component
-  showPageJump: true, // Shows or hides the pagination number input
-  showPageSizeOptions: true, // Enables the user to change the page size
-  pageSizeOptions: [5, 10, 20, 25, 50, 100], // The available page size options
-
-  // Callbacks
-  onChange: (state, instance) => null, // Anytime the internal state of the table changes, this will fire
-
-  // Text
-  previousText: 'Previous',
-  nextText: 'Next'
-
-  // Classes
-  className: '-striped -highlight', // The most top level className for the component
-  tableClassName: '', // ClassName for the `table` element
-  theadClassName: '', // ClassName for the `thead` element
-  tbodyClassName: '', // ClassName for the `tbody` element
-  trClassName: '', // ClassName for all `tr` elements
-  trClassCallback: row => null, // A call back to dynamically add classes (via the classnames module) to a row element
-  paginationClassName: '' // ClassName for `pagination` element
-  // Styles
-  style: {}, // Main style object for the component
-  tableStyle: {}, // style object for the `table` component
-  theadStyle: {}, // style object for the `thead` component
-  tbodyStyle: {}, // style object for the `tbody` component
-  trStyle: {}, // style object for the `tr` component
-  trStyleCallback: row => {}, // A call back to dynamically add styles to a row element
-  thStyle: {}, // style object for the `th` component
-  tdStyle: {}, // style object for the `td` component
-  paginationStyle: {}, // style object for the `paginination` component
-}
-```
-
-You can easily override the core defaults like so:
+2.  Import the `react-table` module

 ```javascript
-import { ReactTableDefaults } from 'react-table'
-
-Object.assign(ReactTableDefaults, {
-  pageSize: 10,
-  minRows: 3,
-  // etc...
-})
+import { useReactTable } from "react-table";
 ```

-Or just define them on the component per-instance
+## Examples

-```javascript
-<ReactTable
-  pageSize={10}
-  minRows={3}
-  // etc...
-  />
-```
+[React Table v7 Sandbox](https://codesandbox.io/s/m5lxzzpz69)

-<a name="columns"></a>
-## Columns
-`<ReactTable/>` requires a `columns` prop, which is an array of objects with the following properties
-
-```javascript
-[{
-  // General
-  accessor: 'propertyName' or Accessor eg. (row) => row.propertyName,
-  id: 'myProperty', // Conditional - A unique ID is required if the accessor is not a string or if you would like to override the column name used in server-side calls
-  sortable: true,
-  sort: 'asc' or 'desc', // used to determine the column sorting on init
-  show: true, // can be used to hide a column
-  minWidth: Number // Allows the column to flex above this minimum amount
-
-  // Cell Options
-  className: '', // Set the classname of the `td` element of the column
-  style: {}, // Set the style of the `td` element of the column
-  innerClassName: '', // Set the classname of the `.-td-inner` element of the column
-  innerStyle: {}, // Set the style of the `.-td-inner` element of the column
-  render: JSX eg. ({value, rowValues, row, index, viewIndex}) => <span>{value}</span>, // Provide a JSX element or stateless function to render whatever you want as the column's cell with access to the entire row
-    // value == the accessed value of the column
-    // rowValues == an object of all of the accessed values for the row
-    // row == the original row of data supplied to the table
-    // index == the original index of the data supplied to the table
-    // viewIndex == the index of the row in the current page
-
-  // Header & HeaderGroup Options
-  header: 'Header Name' or JSX eg. ({data, column}) => <div>Header Name</div>,
-  headerClassName: '', // Set the classname of the `th` element of the column
-  headerStyle: {}, // Set the style of the `th` element of the column
-  headerInnerClassName: '', // Set the classname of the `.-th-inner` element of the column
-  headerInnerStyle: {}, // Set the style of the `.th-inner` element of the column
-
-  // Header Groups only
-  columns: [...] // See Header Groups section below
-
-}]
-```
-
-<a name="styles"></a>
-## Styles
-React-table is built to be dropped into existing applications or styled from the ground up, but if you'd like a decent starting point, you can optionally include our default theme `react-table.css`.  We think it looks great, honestly :)
-
-<a name="header-groups"></a>
-## Header Groups
-To group columns with another header column, just nest your columns in a header column like so:
-```javascript
-const columns = [{
-  header: 'Favorites',
-  columns: [{
-    header: 'Color',
-    accessor: 'favorites.color'
-  }, {
-    header: 'Food',
-    accessor: 'favorites.food'
-  } {
-    header: 'Actor',
-    accessor: 'favorites.actor'
-  }]
-}]
-```
-
-<a name="server-side-data"></a>
-## Server-side Data
-If you want to handle pagination, and sorting on the server, `react-table` makes it easy on you.
-
-1. Feed React Table `data` from somewhere dynamic. eg. `state`, a redux store, etc...
-1. Add `manual` as a prop. This informs React Table that you'll be handling sorting and pagination server-side
-1. Subscribe to the `onChange` prop. This function is called at `compomentDidMount` and any time sorting or pagination is changed by the user
-1. In the `onChange` callback, request your data using the provided information in the params of the function (state and instance)
-1. Update your data with the rows to be displayed
-1. Optionally set how many pages there are total
-
-```javascript
-<ReactTable
-  ...
-  data={this.state.data} // should default to []
-  pages={this.state.pages} // should default to -1 (which means we don't know how many pages we have)
-  loading={this.state.loading}
-  manual // informs React Table that you'll be handling sorting and pagination server-side
-  onChange={(state, instance) => {
-    // show the loading overlay
-    this.setState({loading: true})
-    // fetch your data
-    Axios.post('mysite.com/data', {
-      page: state.page,
-      pageSize: state.pageSize,
-      sorting: state.sorting
-    })
-      .then((res) => {
-        // Update react-table
-        this.setState({
-          data: res.data.rows,
-          pages: res.data.pages,
-          loading: false
-        })
-      })
-  }}
-/>
-```
-
-For a detailed example, take a peek at our [async table mockup](https://github.com/tannerlinsley/react-table/blob/master/example/src/screens/async.js)
-
-<a name="multi-sort"></a>
-## Multi-Sort
-When clicking on a column header, hold shift to multi-sort! You can toggle `ascending` `descending` and `none` for multi-sort columns. Clicking on a header without holding shift will clear the multi-sort and replace it with the single sort of that column. It's quite handy!
-
-<a name="component-overrides"></a>
-## Component Overrides
-Though we wouldn't suggest it, `react-table` has the ability to change the core componentry it used to render it's table. You can do so by assigning a react component to it's corresponding global prop, or on a one-off basis like so:
-```javascript
-// Change the global default
-import { ReactTableDefaults } from 'react-table'
-Object.assign(ReactTableDefaults, {
-  tableComponent: Component,
-  theadComponent: Component,
-  tbodyComponent: Component,
-  trComponent: Component,
-  thComponent: Component,
-  tdComponent: Component,
-  paginationComponent: Component,
-  previousComponent: Component,
-  nextComponent: Component,
-  loadingComponent: Component
-})
-
-// Or change per instance
-<ReactTable
-  tableComponent={Component},
-  theadComponent={Component},
-  // etc...
-  />
-```
-
-If you choose to change the core components React-Table uses to render, you must make sure your components support and utilized all of the neeeded features for that component to work properly. For a broad reference on how to do this, investigate [the source](https://github.com/tannerlinsley/react-table/blob/master/src/index.js) for the component you wish to replace.
+# Documentation

+Documentation for v7 is coming soon. If you're looking for the [v6 documentation, click here](https://github.com/tannerlinsley/react-table/tree/v6)

 ## Contributing
+
 To suggest a feature, create an issue if it does not already exist.
 If you would like to help develop a suggested feature follow these steps:

 - Fork this repo
- `npm install`
- `npm watch`
+- Install dependencies with `$ yarn`
+- Auto-build files as you edit with `$ yarn run watch`
 - Implement your changes to files in the `src/` directory
+- Run the <a href="https://github.com/tannerlinsley/react-story">React Story</a> locally with `$ yarn run docs`
+- View changes as you edit `docs/src`
 - Submit PR for review

-If you would like to preview your changes, you can link and utilize the example like so:
+#### Package Utilities

- `npm link`
- `cd example`
- `npm install`
- `npm link react-table`
- `npm watch`
- Make changes to the example in `src/screens/index.js` if needed
- View changes at `localhost:8000`
-
-## Used By
-
-<a href='https://nozzle.io'>
-  <img src='https://nozzle.io/img/logo-blue.png' alt='Nozzle Logo' style='width:300px;'/>
-</a>
+- `$ yarn run watch` Watches files and builds via babel
+- `$ yarn run docs` Runs the storybook server
+- `$ yarn run test` Runs the test suite
@@ -1 +0,0 @@
-# Jumpsuit Getting Started
@@ -1,28 +0,0 @@
-var fs = require('fs')
-var path = require('path')
-var stylus = require('stylus')
-var nib = require('nib')
-
-var stylusEntry = path.resolve('src/app.styl')
-
-module.exports = {
-  styles: {
-    extensions: ['.css', '.styl'],
-    action: buildStyles
-  }
-}
-
-function buildStyles () {
-  return new Promise(function (resolve, reject) {
-    stylus.render(fs.readFileSync(stylusEntry, 'utf8'), {
-      'include css': true,
-      'hoist atrules': true,
-      compress: process.env.NODE_ENV === 'production',
-      paths: [path.resolve('src')],
-      use: nib()
-    }, function (err, css) {
-      if (err) reject(err)
-      else resolve(css)
-    })
-  })
-}
@@ -1,28 +0,0 @@
-{
-  "name": "react-table-example",
-  "version": "0.0.1",
-  "description": "Jumpsuit getting started example",
-  "license": "MIT",
-  "private": true,
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/jumpsuit/jumpsuit.git"
-  },
-  "scripts": {
-    "watch": "jumpsuit watch",
-    "build": "jumpsuit build",
-    "deploy": "jumpsuit build && zab deploy"
-  },
-  "devDependencies": {
-    "nib": "^1.1.0",
-    "standard": "^8.4.0",
-    "stylus": "^0.54.5"
-  },
-  "dependencies": {
-    "jumpsuit": "^1.3.3",
-    "lodash": "^4.16.4",
-    "namor": "^0.3.0",
-    "react-syntax-highlighter": "^3.0.0",
-    "react-table": "^3.1.2"
-  }
-}
@@ -1,17 +0,0 @@
-import { Render, Router, Route, IndexRoute } from 'jumpsuit'
-//
-import Layout from 'components/layout'
-import Simple from 'screens/simple'
-import ServerSide from 'screens/serverSide'
-
-Render(null, (
-  <Router>
-    <Route path='/' component={Layout}>
-      <IndexRoute component={Simple} />
-      <Route path='simple' component={Simple} />
-      <Route path='server-side' component={ServerSide} />
-    </Route>
-  </Router>
-), {
-  useHash: false
-})
@@ -1,112 +0,0 @@
-// -----------------------------------------------------------------------------
-// Globals
-// -----------------------------------------------------------------------------
-
-@import url('https://fonts.googleapis.com/css?family=Open+Sans:300,600')
-@import 'nib'
-
-global-reset()
-
-// -----------------------------------------------------------------------------
-// vendor styles
-// -----------------------------------------------------------------------------
-
-@import '../node_modules/react-table/src/index'
-
-// -----------------------------------------------------------------------------
-// variables
-// -----------------------------------------------------------------------------
-
-$fnt-open-sans = 'Open Sans', sans-serif
-$react = #25d8fd
-
-// -----------------------------------------------------------------------------
-// styles
-// -----------------------------------------------------------------------------
-
-*
-  box-sizing border-box
-
-html
-  min-height 100vh
-
-body
-  background: white
-  font-family: $fnt-open-sans
-  font-weight: 300
-
-h1
-  font-size: 2.5em
-  color: white
-
-a
-  color: darken($react, 20%)
-  font-weight: bold
-  text-decoration: none
-
-strong
-  font-weight: bold
-
-.logo
-  width: 400px
-  max-width: 100%
-
-.container
-  display: flex
-  flex-direction: column
-  align-items: center
-  justify-content: center
-  min-height: 100vh
-  padding-top: 20px
-
-  .github-addon
-    font-size: 20px
-    padding: 10px
-
-.viewport
-  width:100%
-
-.table-wrap
-  width: 90%
-  margin: auto
-  padding: 10px
-  border-radius: 5px
-  box-shadow: 0 0 20px 0 alpha(black, .2)
-
-.menu
-  display:block
-  margin: 0 10px 20px
-  ul
-    display:block
-  li
-    display:inline-block
-  a
-    display:block
-    padding: 10px
-    margin: 5px
-    background: alpha(black, .4)
-    color: white
-    border-radius: 3px
-    transition: all .2s ease-out
-    &.active
-    &:hover
-      background: alpha(black, .9)
-
-.ReactTable
-	thead
-		th
-		td
-			&.-sort-asc
-				box-shadow:inset 0 3px 0 0 alpha(black, .6)
-			&.-sort-desc
-				box-shadow:inset 0 -3px 0 0 alpha(black, .6)
-
-pre
-  display:block
-  font-family: monospace
-  font-size: 15px
-  line-height: 20px
-  border-radius: 5px
-  margin: 20px auto
-  max-width: 90%
-  padding: 0 20px !important
@@ -1,14 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>React-Table Demo</title>
-  <link rel="stylesheet" href="/app.css" charset="utf-8">
-</head>
-<body>
-  <div id="app"></div>
-  <script src="/app.js"></script>
-  <script async defer src="https://buttons.github.io/buttons.js"></script>
-</body>
-</html>
@@ -1,11 +0,0 @@
-import { Component } from 'jumpsuit'
-import SyntaxHighlighter from 'react-syntax-highlighter'
-import atomOneDark from '../../node_modules/react-syntax-highlighter/dist/styles/atom-one-dark'
-
-export default Component({
-  render () {
-    return (
-      <SyntaxHighlighter language='javascript' style={atomOneDark}>{this.props.children}</SyntaxHighlighter>
-    )
-  }
-})
@@ -1,59 +0,0 @@
-import { Component, Link } from 'jumpsuit'
-
-export default Component({
-  render () {
-    return (
-      <div className='container'>
-        <div style={{textAlign: 'center'}}>
-          <h1>
-            <span style={{position: 'absolute', textIndent: '-9999em'}}>
-              react-table
-            </span>
-            <img src='/Banner.png' className='logo' />
-          </h1>
-          <br />
-          <div>
-            <a
-              className='github-button'
-              href='https://github.com/tannerlinsley/react-table'
-              target='_blank'
-              data-style='mega'
-              data-count-href='/tannerlinsley/react-table/stargazers'
-              data-count-api='/repos/tannerlinsley/react-table#stargazers_count'
-              data-count-aria-label='# stargazers on GitHub'
-              aria-label='Star tannerlinsley/react-table on GitHub'>
-              Star
-            </a>
-          </div>
-          <br />
-          <div className='github-addon'>
-            <a
-              target='_blank'
-              href='https://github.com/tannerlinsley/react-table'>
-              View on Github
-            </a>
-          </div>
-          <br />
-          <br />
-        </div>
-        <div className='menu'>
-          <ul>
-            <li>
-              <Link to='/simple' activeClassName='active'>
-                Simple
-              </Link>
-            </li>
-            <li>
-              <Link to='/server-side' activeClassName='active'>
-                Server-Side
-              </Link>
-            </li>
-          </ul>
-        </div>
-        <div className='viewport'>
-          {this.props.children}
-        </div>
-      </div>
-    )
-  }
-})
@@ -1,171 +0,0 @@
-import { Component } from 'jumpsuit'
-import _ from 'lodash'
-import namor from 'namor'
-
-import CodeHighlight from 'components/codeHighlight'
-import ReactTable from 'react-table'
-
-// Let's mock some data to play around with
-const rawData = _.map(_.range(3424), d => {
-  return {
-    firstName: namor.generate({ words: 1, numLen: 0 }),
-    lastName: namor.generate({ words: 1, numLen: 0 }),
-    age: Math.floor(Math.random() * 30)
-  }
-})
-
-// Now let's mock the server.  It's job is simple: use the table model to sort and return the page data
-const requestData = (pageSize, page, sorting) => {
-  return new Promise((resolve, reject) => {
-    // On the server, you'll likely use SQL or noSQL or some other query language to do this.
-    // For this mock, we'll just use lodash
-    const sortedData = _.orderBy(rawData, sorting.map(sort => {
-      return row => {
-        if (row[sort.id] === null || row[sort.id] === undefined) {
-          return -Infinity
-        }
-        return typeof row[sort.id] === 'string' ? row[sort.id].toLowerCase() : row[sort.id]
-      }
-    }), sorting.map(d => d.asc ? 'asc' : 'desc'))
-
-    // Be sure to send back the rows to be displayed and any other pertinent information, like how many pages there are total.
-    const res = {
-      rows: sortedData.slice(pageSize * page, (pageSize * page) + pageSize),
-      pages: Math.ceil(rawData.length / pageSize)
-    }
-
-    // Here we'll simulate a server response with 500ms of delay.
-    setTimeout(() => resolve(res), 500)
-  })
-}
-
-export default Component({
-  getInitialState () {
-    // To handle our data server-side, we need a few things in the state to help us out:
-    return {
-      data: [],
-      pages: null,
-      loading: true
-    }
-  },
-  fetchData (state, instance) {
-    // Whenever the table model changes, or the user sorts or changes pages, this method gets called and passed the current table model.
-    // You can set the `loading` prop of the table to true to use the built-in one or show you're own loading bar if you want.
-    this.setState({loading: true})
-    // Request the data however you want.  Here, we'll use our mocked service we created earlier
-    requestData(state.pageSize, state.page, state.sorting)
-      .then((res) => {
-        // Now just get the rows of data to your React Table (and update anything else like total pages or loading)
-        this.setState({
-          data: res.rows,
-          pages: res.pages,
-          loading: false
-        })
-      })
-  },
-  render () {
-    return (
-      <div>
-        <div className='table-wrap'>
-          <ReactTable
-            columns={[{
-              header: 'Name',
-              columns: [{
-                header: 'First Name',
-                accessor: 'firstName'
-              }, {
-                header: 'Last Name',
-                id: 'lastName',
-                accessor: d => d.lastName
-              }]
-            }, {
-              header: 'Info',
-              columns: [{
-                header: 'Age',
-                accessor: 'age'
-              }]
-            }]}
-            manual // Forces table not to paginate or sort automatically, so we can handle it server-side
-            pageSize={10}
-            data={this.state.data} // Set the rows to be displayed
-            pages={this.state.pages} // Display the total number of pages
-            loading={this.state.loading} // Display the loading overlay when we need it
-            onChange={this.fetchData} // Request new data when things change
-          />
-        </div>
-        <div style={{textAlign: 'center'}}>
-          <br />
-          <em>Tip: Hold shift when sorting to multi-sort!</em>
-        </div>
-        <CodeHighlight>{getCode()}</CodeHighlight>
-      </div>
-    )
-  }
-})
-
-function getCode () {
-  return `
-import ReactTable from 'react-table'
-import Axios from 'axios'
-
-export default React.creatClass({
-  getInitialState () {
-    // To handle our data server-side, we need to keep track of our table state
-    return {
-      data: [],
-      pages: null,
-      loading: true
-    }
-  },
-  fetchData (state, instance) {
-    // Whenever the table model changes (sorting, pagination, etc), this method gets called and passed the current table model.
-    // You can set the 'loading' prop of the table to true to use the built-in loading notice, or show you're own loading bar if you want.
-    this.setState({loading: true})
-    // Request the data from a server however you want! Be sure to send the bits of the table model that it may neeed.
-    Axios.post('mysite.com/data', {
-      pageSize: state.pageSize,
-      page: state.page,
-      sorting: state.sorting
-    })
-      .then((res) => {
-        // Now update your state!
-        this.setState({
-          data: res.rows,
-          pages: res.pages,
-          loading: false
-        })
-      })
-  },
-  render () {
-    const columns = [{
-      header: 'Name',
-      columns: [{
-        header: 'First Name',
-        accessor: 'firstName'
-      }, {
-        header: 'Last Name',
-        id: 'lastName',
-        accessor: d => d.lastName
-      }]
-    }, {
-      header: 'Info',
-      columns: [{
-        header: 'Age',
-        accessor: 'age'
-      }]
-    }]
-
-    return (
-      <ReactTable
-        columns={columns}
-        manual // This forces table not to paginate or sort automatically, so we can handle things server-side
-        data={this.state.data} // Set the rows to be displayed
-        pages={this.state.pages} // Display the total number of pages
-        loading={this.state.loading} // Display the loading overlay when we need it
-        onChange={this.fetchData} // Request new data when things change
-      />
-    )
-  }
-})
-  `
-}
@@ -1,103 +0,0 @@
-import { Component } from 'jumpsuit'
-import _ from 'lodash'
-import namor from 'namor'
-
-import CodeHighlight from 'components/codeHighlight'
-import ReactTable from 'react-table'
-
-export default Component({
-  render () {
-    const data = _.map(_.range(5553), d => {
-      return {
-        firstName: namor.generate({ words: 1, numLen: 0 }),
-        lastName: namor.generate({ words: 1, numLen: 0 }),
-        age: Math.floor(Math.random() * 30)
-      }
-    })
-
-    const columns = [{
-      header: 'Name',
-      columns: [{
-        header: 'First Name',
-        accessor: 'firstName'
-      }, {
-        header: 'Last Name',
-        id: 'lastName',
-        accessor: d => d.lastName
-      }]
-    }, {
-      header: 'Info',
-      columns: [{
-        header: 'Age',
-        accessor: 'age'
-      }]
-    }]
-
-    return (
-      <div>
-        <div className='table-wrap'>
-          <ReactTable
-            data={data}
-            columns={columns}
-            pageSize={10}
-          />
-        </div>
-        <div style={{textAlign: 'center'}}>
-          <br />
-          <em>Tip: Hold shift when sorting to multi-sort!</em>
-        </div>
-        <CodeHighlight>{getCode()}</CodeHighlight>
-      </div>
-    )
-  }
-})
-
-function getCode () {
-  return `
-import ReactTable from 'react-table'
-
-// To help us mock some data
-import namor from 'namor'
-import _ from 'lodash'
-
-export default () => {
-
-  // Mock some data
-  const data = _.map(_.range(5553), d => {
-    return {
-      firstName: namor.generate({ words: 1, numLen: 0 }),
-      lastName: namor.generate({ words: 1, numLen: 0 }),
-      age: Math.floor(Math.random() * 30)
-    }
-  })
-
-  // Create some column definitions
-  const columns = [{
-    header: 'Name',
-    columns: [{
-      header: 'First Name',
-      accessor: 'firstName'
-    }, {
-      header: 'Last Name',
-      id: 'lastName',
-      accessor: d => d.lastName
-    }]
-  }, {
-    header: 'Info',
-    columns: [{
-      header: 'Age',
-      accessor: 'age'
-    }]
-  }]
-
-  // Display your table!
-  return (
-    <ReactTable
-      data={data}
-      columns={columns}
-      pageSize={10}
-    />
-  )
-})
-  `
-}
@@ -1,8 +0,0 @@
-{
-  "name": "react-table",
-  "root": "dist",
-  "routes": [{
-    "src": "/**",
-    "dest": "index.html"
-  }]
-}
@@ -1,6 +1,6 @@
 {
  "name": "react-table",
-  "version": "3.1.4",
+  "version": "7.0.0-alpha.0",
  "description": "A fast, lightweight, opinionated table and datagrid built on React",
  "license": "MIT",
  "homepage": "https://github.com/tannerlinsley/react-table#readme",
@@ -14,62 +14,52 @@
    "react-table",
    "datagrid"
  ],
-  "main": "lib/index.js",
+  "main": "dist/index.js",
+  "_module": "dist/index.es.js",
+  "_jsnext:main": "dist/index.es.js",
+  "scripts": {
+    "test": "cross-env CI=1 react-scripts test --env=jsdom",
+    "test:watch": "react-scripts test --env=jsdom",
+    "build": "rollup -c",
+    "start": "rollup -c -w",
+    "prepare": "yarn build",
+    "release": "yarn publish",
+    "releaseNext": "yarn publish --tag next"
+  },
  "files": [
    "src/",
+    "es/",
    "lib/",
    "react-table.js",
+    "react-table.min.js",
    "react-table.css",
    "media/*.png"
  ],
-  "scripts": {
-    "build:node": "babel src --out-dir lib --source-maps inline",
-    "build:css": "rm -rf react-table.css && stylus src/index.styl --use ./node_modules/nib/lib/nib.js --compress -o react-table.css",
-    "watch": "onchange 'src/**' -i -- npm-run-all build:*",
-    "test": "standard",
-    "umd": "rm -rf react-table.js && browserify lib/index.js -s reactTable -x react -t babelify -g uglifyify -o react-table.js",
-    "prepublish": "npm-run-all build:* && npm run umd",
-    "postpublish": "git push --tags"
-  },
-  "dependencies": {
-    "classnames": "^2.2.5"
-  },
  "peerDependencies": {
-    "react": "^15.3.1"
+    "prop-types": "^15.5.0",
+    "react": "^16.7.0-alpha.0 || ^16.8.x",
+    "react-dom": "^16.7.0-alpha.0 || ^16.8.x"
  },
  "devDependencies": {
-    "babel-cli": "6.14.0",
-    "babel-eslint": "6.1.2",
-    "babel-preset-es2015": "6.14.0",
-    "babel-preset-react": "6.11.1",
-    "babel-preset-stage-2": "6.13.0",
-    "babelify": "^7.3.0",
-    "browserify": "13.1.0",
-    "nib": "^1.1.2",
-    "npm-run-all": "^3.1.1",
-    "onchange": "^3.0.2",
-    "standard": "^8.0.0",
-    "stylus": "^0.54.5",
-    "uglifyify": "3.0.3"
-  },
-  "browserify-shim": {
-    "react": "global:React"
-  },
-  "standard": {
-    "parser": "babel-eslint",
-    "ignore": [
-      "node_modules",
-      "dist",
-      "lib",
-      "example",
-      "react-table.js"
-    ]
-  },
-  "babel": {
-    "presets": [
-      "es2015",
-      "stage-2",
-      "react"
-    ]
+    "@babel/plugin-proposal-class-properties": "^7.2.1",
+    "@babel/preset-env": "^7.2.0",
+    "@babel/preset-react": "^7.0.0",
+    "@babel/runtime": "^7.2.0",
+    "@svgr/rollup": "^4.1.0",
+    "babel-core": "7.0.0-bridge.0",
+    "cross-env": "^5.1.4",
+    "eslint": "^5.10.0",
+    "eslint-config-standard": "^12.0.0",
+    "eslint-config-standard-react": "^7.0.2",
+    "eslint-plugin-import": "^2.13.0",
+    "eslint-plugin-node": "^8.0.0",
+    "eslint-plugin-promise": "^4.0.0",
+    "eslint-plugin-react": "^7.10.0",
+    "eslint-plugin-standard": "^4.0.0",
+    "rollup": "^0.68.0",
+    "rollup-plugin-babel": "^4.1.0",
+    "rollup-plugin-commonjs": "^9.1.3",
+    "rollup-plugin-node-resolve": "^4.0.0",
+    "rollup-plugin-peer-deps-external": "^2.2.0"
  }
 }
@@ -0,0 +1,42 @@
+import nodeResolve from 'rollup-plugin-node-resolve'
+import babel from 'rollup-plugin-babel'
+import replace from 'rollup-plugin-replace'
+import commonjs from 'rollup-plugin-commonjs'
+import uglify from 'rollup-plugin-uglify'
+
+const env = process.env.NODE_ENV
+
+const config = {
+  input: 'src/index.js',
+  output: {
+    file: env === 'production' ? 'react-table.min.js' : 'react-table.js',
+    format: 'umd',
+    globals: {
+      react: 'React',
+    },
+    name: 'ReactTable',
+    exports: 'named',
+  },
+  external: ['react'],
+  plugins: [
+    nodeResolve(),
+    babel({
+      exclude: '**/node_modules/**',
+    }),
+    replace({
+      'process.env.NODE_ENV': JSON.stringify(env),
+    }),
+    commonjs(),
+  ],
+}
+
+if (env === 'production') {
+  config.plugins.push(uglify({
+    compress: {
+      dead_code: true,
+      warnings: false,
+    },
+  }))
+}
+
+export default config
@@ -0,0 +1,7 @@
+export function sum (values, rows) {
+  return values.reduce((sum, next) => sum + next, 0)
+}
+
+export function average (values, rows) {
+  return Math.round((sum(values, rows) / values.length) * 100) / 100
+}
@@ -0,0 +1,41 @@
+import { useMemo } from 'react'
+
+export default function useAccessedRows ({
+  debug, data, columns, subRowsKey,
+}) {
+  return useMemo(
+    () => {
+      if (debug) console.info('getAccessedRows')
+
+      // Access the row's data
+      const accessRow = (data, i, depth = 0) => {
+        // Keep the original reference around
+        const original = data
+
+        // Process any subRows
+        const subRows = data[subRowsKey]
+          ? data[subRowsKey].map((d, i) => accessRow(d, i, depth + 1))
+          : undefined
+
+        const row = {
+          original,
+          index: i,
+          subRows,
+          depth,
+        }
+
+        // Create the cells and values
+        row.values = {}
+        columns.forEach(column => {
+          row.values[column.id] = column.accessor ? column.accessor(data) : undefined
+        })
+
+        return row
+      }
+
+      // Use the resolved data
+      return data.map((d, i) => accessRow(d, i))
+    },
+    [data, columns]
+  )
+}
@@ -0,0 +1,201 @@
+import { useMemo } from 'react'
+
+import { getFirstDefined, getBy } from '../utils'
+
+export default function useColumns ({
+  debug,
+  groupBy,
+  userColumns,
+  disableSorting,
+  disableGrouping,
+  disableFilters,
+}) {
+  return useMemo(
+    () => {
+      if (debug) console.info('getColumns')
+
+      // Decorate All the columns
+      const columnTree = decorateColumnTree(userColumns)
+
+      // Get the flat list of all columns
+      let columns = flattenBy(columnTree, 'columns')
+
+      columns = [
+        ...groupBy.map(g => columns.find(col => col.id === g)),
+        ...columns.filter(col => !groupBy.includes(col.id)),
+      ]
+
+      // Get headerGroups
+      const headerGroups = makeHeaderGroups(columns, findMaxDepth(columnTree))
+      const headers = flattenBy(headerGroups, 'headers')
+
+      return {
+        columns,
+        headerGroups,
+        headers,
+      }
+    },
+    [groupBy, userColumns]
+  )
+
+  // Find the depth of the columns
+  function findMaxDepth (columns, depth = 0) {
+    return columns.reduce((prev, curr) => {
+      if (curr.columns) {
+        return Math.max(prev, findMaxDepth(curr.columns, depth + 1))
+      }
+      return depth
+    }, 0)
+  }
+
+  function decorateColumn (column, parent) {
+    // First check for string accessor
+    let {
+      id, accessor, Header, canSortBy, canGroupBy, canFilter,
+    } = column
+
+    if (typeof accessor === 'string') {
+      id = id || accessor
+      const accessorString = accessor
+      accessor = row => getBy(row, accessorString)
+    }
+
+    const grouped = groupBy.includes(id)
+
+    canSortBy = accessor
+      ? getFirstDefined(canSortBy, disableSorting === true ? false : undefined, true)
+      : false
+    canGroupBy = accessor
+      ? getFirstDefined(canGroupBy, disableGrouping === true ? false : undefined, true)
+      : false
+    canFilter = accessor
+      ? getFirstDefined(canFilter, disableFilters === true ? false : undefined, true)
+      : false
+
+    if (!id && typeof Header === 'string') {
+      id = Header
+    }
+
+    if (!id) {
+      // Accessor, but no column id? This is bad.
+      console.error(column)
+      throw new Error('A column id is required!')
+    }
+
+    column = {
+      Header: '',
+      Cell: cell => cell.value,
+      show: true,
+      ...column,
+      grouped,
+      canSortBy,
+      canGroupBy,
+      canFilter,
+      id,
+      accessor,
+      parent,
+    }
+
+    column.Aggregated = column.Aggregated || column.Cell
+
+    return column
+  }
+
+  // Build the visible columns, headers and flat column list
+  function decorateColumnTree (columns, parent, depth = 0) {
+    return columns.map(column => {
+      column = decorateColumn(column, parent)
+      if (column.columns) {
+        column.columns = decorateColumnTree(column.columns, column, depth + 1)
+      }
+      return column
+    })
+  }
+
+  function flattenBy (columns, childKey) {
+    const flatColumns = []
+
+    const recurse = columns => {
+      columns.forEach(d => {
+        if (!d[childKey]) {
+          flatColumns.push(d)
+        } else {
+          recurse(d[childKey])
+        }
+      })
+    }
+
+    recurse(columns)
+
+    return flatColumns
+  }
+
+  // Build the header groups from the bottom up
+  function makeHeaderGroups (columns, maxDepth) {
+    const headerGroups = []
+
+    const removeChildColumns = column => {
+      delete column.columns
+      if (column.parent) {
+        removeChildColumns(column.parent)
+      }
+    }
+    columns.forEach(removeChildColumns)
+
+    const buildGroup = (columns, depth = 0) => {
+      const headerGroup = {
+        headers: [],
+      }
+
+      const parentColumns = []
+
+      const hasParents = columns.some(col => col.parent)
+
+      columns.forEach(column => {
+        const isFirst = !parentColumns.length
+        let latestParentColumn = [...parentColumns].reverse()[0]
+
+        // If the column has a parent, add it if necessary
+        if (column.parent) {
+          if (isFirst || latestParentColumn.originalID !== column.parent.id) {
+            parentColumns.push({
+              ...column.parent,
+              originalID: column.parent.id,
+              id: [column.parent.id, parentColumns.length].join('_'),
+            })
+          }
+        } else if (hasParents) {
+          // If other columns have parents, add a place holder if necessary
+          const placeholderColumn = decorateColumn({
+            originalID: [column.id, 'placeholder', maxDepth - depth].join('_'),
+            id: [column.id, 'placeholder', maxDepth - depth, parentColumns.length].join('_'),
+          })
+          if (isFirst || latestParentColumn.originalID !== placeholderColumn.originalID) {
+            parentColumns.push(placeholderColumn)
+          }
+        }
+
+        // Establish the new columns[] relationship on the parent
+        if (column.parent || hasParents) {
+          latestParentColumn = [...parentColumns].reverse()[0]
+          latestParentColumn.columns = latestParentColumn.columns || []
+          if (!latestParentColumn.columns.includes(column)) {
+            latestParentColumn.columns.push(column)
+          }
+        }
+
+        headerGroup.headers.push(column)
+      })
+
+      headerGroups.push(headerGroup)
+
+      if (parentColumns.length) {
+        buildGroup(parentColumns)
+      }
+    }
+
+    buildGroup(columns)
+
+    return headerGroups.reverse()
+  }
+}
@@ -0,0 +1,24 @@
+const mergeStateAndProps = (state, defaults, props) => {
+  Object.keys(props).forEach(key => {
+    if (typeof props[key] !== 'undefined') {
+      state[key] = props[key]
+    }
+  })
+
+  Object.keys(defaults).forEach(key => {
+    if (typeof state[key] === 'undefined') {
+      state[key] = defaults[key]
+    }
+  })
+
+  return state
+}
+
+export default function useControlledState ([userState, userSetState], defaults, props) {
+  const state = mergeStateAndProps(userState, defaults, props)
+
+  const setState = (updater, type) =>
+    userSetState(old => updater(mergeStateAndProps(old, defaults, props)), type)
+
+  return [state, setState]
+}
@@ -0,0 +1,55 @@
+import { useMemo, useEffect } from 'react'
+
+import { getBy } from '../utils'
+
+export default function useExpandedRows ({
+  debug,
+  expanded,
+  expandedKey,
+  columns,
+  rows,
+  setState,
+  actions,
+}) {
+  return useMemo(
+    () => {
+      if (debug) console.info('getExpandedRows')
+
+      const expandedRows = []
+
+      // Here we do some mutation, but it's the last stage in the
+      // immutable process so this is safe
+      const handleRow = (row, index, depth = 0, parentPath = []) => {
+        // Compute some final state for the row
+        const path = [...parentPath, index]
+
+        row.path = path
+        row.depth = depth
+
+        row.isExpanded = (row.original && row.original[expandedKey]) || getBy(expanded, path)
+
+        row.cells = columns.map(column => {
+          const cell = {
+            column,
+            row,
+            state: null,
+            value: row.values[column.id],
+          }
+
+          return cell
+        })
+
+        expandedRows.push(row)
+
+        if (row.isExpanded && row.subRows && row.subRows.length) {
+          row.subRows.forEach((row, i) => handleRow(row, i, depth + 1, path))
+        }
+      }
+
+      rows.forEach((row, i) => handleRow(row, i))
+
+      return expandedRows
+    },
+    [rows, expanded, columns]
+  )
+}
@@ -0,0 +1,67 @@
+import { useMemo } from 'react'
+
+export default function useFilteredRows ({
+  debug,
+  filters,
+  rows,
+  columns,
+  filterFn,
+  manualFilters,
+}) {
+  return useMemo(
+    () => {
+      if (manualFilters || !Object.keys(filters).length) {
+        return rows
+      }
+
+      if (debug) console.info('getFilteredRows')
+
+      // Filters top level and nested rows
+      const filterRows = rows => {
+        let filteredRows = rows
+
+        filteredRows = Object.entries(filters).reduce((filteredSoFar, [columnID, filterValue]) => {
+          // Find the filters column
+          const column = columns.find(d => d.id === columnID)
+
+          // Don't filter hidden columns or columns that have had their filters disabled
+          if (!column || column.filterable === false) {
+            return filteredSoFar
+          }
+
+          const filterMethod = column.filterMethod || filterFn
+
+          // If 'filterAll' is set to true, pass the entire dataset to the filter method
+          if (column.filterAll) {
+            return filterMethod(filteredSoFar, columnID, filterValue, column)
+          }
+          return filteredSoFar.filter(row => filterMethod(row, columnID, filterValue, column))
+        }, rows)
+
+        // Apply the filter to any subRows
+        filteredRows = filteredRows.map(row => {
+          if (!row.subRows) {
+            return row
+          }
+          return {
+            ...row,
+            subRows: filterRows(row.subRows),
+          }
+        })
+
+        // then filter any rows without subcolumns because it would be strange to show
+        filteredRows = filteredRows.filter(row => {
+          if (!row.subRows) {
+            return true
+          }
+          return row.subRows.length > 0
+        })
+
+        return filteredRows
+      }
+
+      return filterRows(rows)
+    },
+    [rows, filters, manualFilters]
+  )
+}
@@ -0,0 +1,77 @@
+import { useMemo } from 'react'
+
+import * as aggregations from '../aggregations'
+
+export default function useGroupedRows ({
+  debug,
+  groupBy,
+  rows,
+  columns,
+  groupByFn,
+  manualGroupBy,
+  userAggregations,
+}) {
+  return useMemo(
+    () => {
+      if (manualGroupBy || !groupBy.length) {
+        return rows
+      }
+      if (debug) console.info('getGroupedRows')
+      // Find the columns that can or are aggregating
+
+      // Uses each column to aggregate rows into a single value
+      const aggregateRowsToValues = rows => {
+        const values = {}
+        columns.forEach(column => {
+          const columnValues = rows.map(d => d.values[column.id])
+          const aggregate =
+            userAggregations[column.aggregate] || aggregations[column.aggregate] || column.aggregate
+          if (typeof aggregate === 'function') {
+            values[column.id] = aggregate(columnValues, rows)
+          } else if (aggregate) {
+            throw new Error(
+              `Invalid aggregate "${aggregate}" passed to column with ID: "${column.id}"`
+            )
+          } else {
+            values[column.id] = columnValues[0]
+          }
+        })
+        return values
+      }
+
+      // Recursively group the data
+      const groupRecursively = (rows, groupBy, depth = 0) => {
+        // This is the last level, just return the rows
+        if (depth >= groupBy.length) {
+          return rows
+        }
+
+        // Group the rows together for this level
+        const groupedRows = Object.entries(groupByFn(rows, groupBy[depth])).map(
+          ([groupByVal, subRows], index) => {
+            // Recurse to sub rows before aggregation
+            subRows = groupRecursively(subRows, groupBy, depth + 1)
+
+            const values = aggregateRowsToValues(subRows)
+
+            const row = {
+              groupByID: groupBy[depth],
+              groupByVal,
+              values,
+              subRows,
+              depth,
+              index,
+            }
+            return row
+          }
+        )
+
+        return groupedRows
+      }
+
+      // Assign the new data
+      return groupRecursively(rows, groupBy)
+    },
+    [rows, groupBy, columns, manualGroupBy]
+  )
+}
@@ -0,0 +1,60 @@
+import { useMemo } from 'react'
+
+export default function useSortedRows ({
+  debug,
+  sortBy,
+  rows,
+  columns,
+  orderByFn,
+  sortByFn,
+  manualSorting,
+}) {
+  return useMemo(
+    () => {
+      if (manualSorting || !sortBy.length) {
+        return rows
+      }
+      if (debug) console.info('getSortedRows')
+
+      const sortMethodsByColumnID = {}
+
+      columns
+        .filter(col => col.sortMethod)
+        .forEach(col => {
+          sortMethodsByColumnID[col.id] = col.sortMethod
+        })
+
+      const sortData = rows => {
+        // Use the orderByFn to compose multiple sortBy's together.
+        // This will also perform a stable sorting using the row index
+        // if needed.
+        const sortedData = orderByFn(
+          rows,
+          sortBy.map(sort => {
+            // Support custom sorting methods for each column
+            const columnSortBy = sortMethodsByColumnID[sort.id]
+
+            // Return the correct sortFn
+            return (a, b) =>
+              (columnSortBy || sortByFn)(a.values[sort.id], b.values[sort.id], sort.desc)
+          }),
+          // Map the directions
+          sortBy.map(d => !d.desc)
+        )
+
+        // TODO: this should be optimized. Not good to loop again
+        sortedData.forEach(row => {
+          if (!row.subRows) {
+            return
+          }
+          row.subRows = sortData(row.subRows)
+        })
+
+        return sortedData
+      }
+
+      return sortData(rows)
+    },
+    [rows, columns, sortBy, manualSorting]
+  )
+}
@@ -0,0 +1,156 @@
+import { getBy, setBy, getFirstDefined } from '../utils'
+
+export default function useTableMethods ({
+  debug,
+  setState,
+  actions,
+  groupBy,
+  columns,
+  defaultSortDesc,
+  filters,
+}) {
+  const toggleExpandedByPath = (path, set) =>
+    setState(old => {
+      const { expanded } = old
+      const existing = getBy(expanded, path)
+      set = getFirstDefined(set, !existing)
+      return {
+        ...old,
+        expanded: setBy(expanded, path, set),
+      }
+    }, actions.toggleExpanded)
+
+  // Updates sorting based on a columnID, desc flag and multi flag
+  const toggleSortByID = (columnID, desc, multi) =>
+    setState(old => {
+      const { sortBy } = old
+
+      // Find the column for this columnID
+      const column = columns.find(d => d.id === columnID)
+      const resolvedDefaultSortDesc = getFirstDefined(column.defaultSortDesc, defaultSortDesc)
+
+      // Find any existing sortBy for this column
+      const existingSortBy = sortBy.find(d => d.id === columnID)
+      const hasDescDefined = typeof desc !== 'undefined' && desc !== null
+
+      let newSortBy = []
+
+      // What should we do with this filter?
+      let action
+
+      if (!multi) {
+        if (sortBy.length <= 1 && existingSortBy) {
+          if (existingSortBy.desc) {
+            action = 'remove'
+          } else {
+            action = 'toggle'
+          }
+        } else {
+          action = 'replace'
+        }
+      } else if (!existingSortBy) {
+        action = 'add'
+      } else if (hasDescDefined) {
+        action = 'set'
+      } else {
+        action = 'toggle'
+      }
+
+      if (action === 'replace') {
+        newSortBy = [
+          {
+            id: columnID,
+            desc: hasDescDefined ? desc : resolvedDefaultSortDesc,
+          },
+        ]
+      } else if (action === 'add') {
+        newSortBy = [
+          ...sortBy,
+          {
+            id: columnID,
+            desc: hasDescDefined ? desc : resolvedDefaultSortDesc,
+          },
+        ]
+      } else if (action === 'set') {
+        newSortBy = sortBy.map(d => {
+          if (d.id === columnID) {
+            return {
+              ...d,
+              desc,
+            }
+          }
+          return d
+        })
+      } else if (action === 'toggle') {
+        newSortBy = sortBy.map(d => {
+          if (d.id === columnID) {
+            return {
+              ...d,
+              desc: !existingSortBy.desc,
+            }
+          }
+          return d
+        })
+      } else if (action === 'remove') {
+        newSortBy = []
+      }
+
+      return {
+        ...old,
+        sortBy: newSortBy,
+      }
+    }, actions.sortByChange)
+
+  const toggleGroupBy = (id, toggle) =>
+    setState(old => {
+      const resolvedToggle = typeof set !== 'undefined' ? toggle : !groupBy.includes(id)
+      if (resolvedToggle) {
+        return {
+          ...old,
+          groupBy: [...groupBy, id],
+        }
+      }
+      return {
+        ...old,
+        groupBy: groupBy.filter(d => d !== id),
+      }
+    }, actions.toggleGroupBy)
+
+  const setFilter = (id, val) =>
+    setState(old => {
+      if (typeof val === 'undefined') {
+        const { [id]: prev, ...rest } = filters
+        return {
+          ...old,
+          filters: {
+            ...rest,
+          },
+        }
+      }
+
+      return {
+        ...old,
+        filters: {
+          ...filters,
+          [id]: val,
+        },
+      }
+    }, actions.setFilter)
+
+  const setAllFilters = filters =>
+    setState(
+      old => ({
+        ...old,
+        filters,
+      }),
+      actions.setAllFilters
+    )
+
+  return {
+    toggleExpandedByPath,
+    toggleSortByID,
+    toggleGroupBy,
+    setFilter,
+    setAllFilters,
+  }
+}
@@ -1,502 +1,11 @@
-import React from 'react'
-import classnames from 'classnames'
-//
-import _ from './utils'
+import useReactTable, { actions as mainActions } from './useReactTable'
+import usePagination, { actions as paginationActions } from './usePagination'
+import useFlexLayout, { actions as flexLayoutActions } from './useFlexLayout'

-import Pagination from './pagination'
-
-export const ReactTableDefaults = {
-  // General
-  data: [],
-  loading: false,
-  pageSize: 20,
-  showPagination: true,
-  showPageSizeOptions: true,
-  pageSizeOptions: [5, 10, 20, 25, 50, 100],
-  showPageJump: true,
-  // Callbacks
-  onChange: () => null,
-  // Classes
-  className: '-striped -highlight',
-  tableClassName: '',
-  theadClassName: '',
-  tbodyClassName: '',
-  trClassName: '',
-  trClassCallback: d => null,
-  thClassName: '',
-  thGroupClassName: '',
-  tdClassName: '',
-  paginationClassName: '',
-  // Styles
-  style: {},
-  tableStyle: {},
-  theadStyle: {},
-  tbodyStyle: {},
-  trStyle: {},
-  trStyleCallback: d => {},
-  thStyle: {},
-  tdStyle: {},
-  paginationStyle: {},
-  // Global Column Defaults
-  column: {
-    sortable: true,
-    show: true,
-    className: '',
-    style: {},
-    innerClassName: '',
-    innerStyle: {},
-    headerClassName: '',
-    headerStyle: {},
-    headerInnerClassName: '',
-    headerInnerStyle: {}
-  },
-  // Text
-  previousText: 'Previous',
-  nextText: 'Next',
-  loadingText: 'Loading...',
-  // Components
-  tableComponent: (props) => <table {...props}>{props.children}</table>,
-  theadComponent: (props) => <thead {...props}>{props.children}</thead>,
-  tbodyComponent: (props) => <tbody {...props}>{props.children}</tbody>,
-  trComponent: (props) => <tr {...props}>{props.children}</tr>,
-  thComponent: (props) => {
-    const {toggleSort, ...rest} = props
-    return (
-      <th {...rest} onClick={e => {
-        toggleSort && toggleSort(e)
-      }}>{props.children}</th>
-    )
-  },
-  tdComponent: (props) => <td {...props}>{props.children}</td>,
-  previousComponent: null,
-  nextComponent: null,
-  loadingComponent: props => (
-    <div className={classnames('-loading', {'-active': props.loading})}>
-      <div className='-loading-inner'>
-        {props.loadingText}
-      </div>
-    </div>
-  )
+const actions = {
+  ...mainActions,
+  ...paginationActions,
+  ...flexLayoutActions,
 }

-export default React.createClass({
-  getDefaultProps () {
-    return ReactTableDefaults
-  },
-  getInitialState () {
-    return {
-      page: 0,
-      sorting: false
-    }
-  },
-  componentDidMount () {
-    this.fireOnChange()
-  },
-  fireOnChange () {
-    this.props.onChange({
-      page: this.getPropOrState('page'),
-      pageSize: this.getStateOrProp('pageSize'),
-      pages: this.getPagesLength(),
-      sorting: this.getSorting()
-    }, this)
-  },
-  getPropOrState (key) {
-    return _.getFirstDefined(this.props[key], this.state[key])
-  },
-  getStateOrProp (key) {
-    return _.getFirstDefined(this.state[key], this.props[key])
-  },
-  getInitSorting (columns) {
-    if (!columns) {
-      return []
-    }
-    const initSorting = columns.filter(d => {
-      return typeof d.sort !== 'undefined'
-    }).map(d => {
-      return {
-        id: d.id,
-        asc: d.sort === 'asc'
-      }
-    })
-
-    return initSorting.length ? initSorting : [{
-      id: columns[0].id,
-      asc: true
-    }]
-  },
-  sortData (data, sorting) {
-    return _.orderBy(data, sorting.map(sort => {
-      return row => {
-        if (row[sort.id] === null || row[sort.id] === undefined) {
-          return -Infinity
-        }
-        return typeof row[sort.id] === 'string' ? row[sort.id].toLowerCase() : row[sort.id]
-      }
-    }), sorting.map(d => d.asc ? 'asc' : 'desc'))
-  },
-  makeDecoratedColumn (column) {
-    const dcol = Object.assign({}, this.props.column, column)
-
-    if (typeof dcol.accessor === 'string') {
-      dcol.id = dcol.id || dcol.accessor
-      const accessorString = dcol.accessor
-      dcol.accessor = row => _.get(row, accessorString)
-      return dcol
-    }
-
-    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.')
-    }
-
-    if (!dcol.accessor) {
-      dcol.accessor = d => undefined
-    }
-
-    return dcol
-  },
-  getSorting (columns) {
-    return this.props.sorting || (this.state.sorting && this.state.sorting.length ? this.state.sorting : this.getInitSorting(columns))
-  },
-  getPagesLength () {
-    return this.props.manual ? this.props.pages
-      : Math.ceil(this.props.data.length / this.getStateOrProp('pageSize'))
-  },
-  getMinRows () {
-    return _.getFirstDefined(this.props.minRows, this.getStateOrProp('pageSize'))
-  },
-  render () {
-    // Build Columns
-    const decoratedColumns = []
-    const headerGroups = []
-    let currentSpan = []
-
-    // Determine Header Groups
-    let hasHeaderGroups = false
-    this.props.columns
-    .forEach(column => {
-      if (column.columns) {
-        hasHeaderGroups = true
-      }
-    })
-
-    // A convenience function to add a header and reset the currentSpan
-    const addHeader = (columns, column = {}) => {
-      headerGroups.push(Object.assign({}, column, {
-        columns: columns
-      }))
-      currentSpan = []
-    }
-
-    // Build the columns and headers
-    const visibleColumns = this.props.columns.filter(d => _.getFirstDefined(d.show, true))
-    visibleColumns.forEach((column, i) => {
-      if (column.columns) {
-        const nestedColumns = column.columns.filter(d => _.getFirstDefined(d.show, true))
-        nestedColumns.forEach(nestedColumn => {
-          decoratedColumns.push(this.makeDecoratedColumn(nestedColumn))
-        })
-        if (hasHeaderGroups) {
-          if (currentSpan.length > 0) {
-            addHeader(currentSpan)
-          }
-          addHeader(_.takeRight(decoratedColumns, nestedColumns.length), column)
-        }
-      } else {
-        decoratedColumns.push(this.makeDecoratedColumn(column))
-        currentSpan.push(_.last(decoratedColumns))
-      }
-    })
-
-    if (hasHeaderGroups && currentSpan.length > 0) {
-      addHeader(currentSpan)
-    }
-
-    const sorting = this.getSorting(decoratedColumns)
-    const accessedData = this.props.data.map((d, i) => {
-      const row = {
-        __original: d,
-        __index: i
-      }
-      decoratedColumns.forEach(column => {
-        row[column.id] = column.accessor(d)
-      })
-      return row
-    })
-    const data = this.props.manual ? accessedData : this.sortData(accessedData, sorting)
-
-    // Normalize state
-    const currentPage = this.getPropOrState('page')
-    const pageSize = this.getStateOrProp('pageSize')
-    const pagesLength = this.getPagesLength()
-
-    // Pagination
-    const startRow = pageSize * currentPage
-    const endRow = startRow + pageSize
-    const pageRows = this.props.manual ? data : data.slice(startRow, endRow)
-    const minRows = this.getMinRows()
-    const padRows = pagesLength > 1 ? _.range(pageSize - pageRows.length)
-      : minRows ? _.range(Math.max(minRows - pageRows.length, 0))
-      : []
-
-    const canPrevious = currentPage > 0
-    const canNext = currentPage + 1 < pagesLength
-
-    const TableComponent = this.props.tableComponent
-    const TheadComponent = this.props.theadComponent
-    const TbodyComponent = this.props.tbodyComponent
-    const TrComponent = this.props.trComponent
-    const ThComponent = this.props.thComponent
-    const TdComponent = this.props.tdComponent
-    const PreviousComponent = this.props.previousComponent
-    const NextComponent = this.props.nextComponent
-    const LoadingComponent = this.props.loadingComponent
-
-    return (
-      <div
-        className={classnames(this.props.className, 'ReactTable')}
-        style={this.props.style}
-      >
-        <TableComponent
-          className={classnames(this.props.tableClassName)}
-          style={this.props.tableStyle}
-        >
-          {hasHeaderGroups && (
-            <TheadComponent
-              className={classnames(this.props.theadGroupClassName, '-headerGroups')}
-              style={this.props.theadStyle}
-            >
-              <TrComponent
-                className={this.props.trClassName}
-                style={this.props.trStyle}
-              >
-                {headerGroups.map((column, i) => {
-                  return (
-                    <ThComponent
-                      key={i}
-                      colSpan={column.columns.length}
-                      className={classnames(this.props.thClassname, column.headerClassName)}
-                      style={Object.assign({}, this.props.thStyle, column.headerStyle)}
-                    >
-                      <div
-                        className={classnames(column.headerInnerClassName, '-th-inner')}
-                        style={Object.assign({}, this.props.thInnerStyle, column.headerInnerStyle)}
-                      >
-                        {typeof column.header === 'function' ? (
-                          <column.header
-                            data={this.props.data}
-                            column={column}
-                          />
-                        ) : column.header}
-                      </div>
-                    </ThComponent>
-                  )
-                })}
-              </TrComponent>
-            </TheadComponent>
-          )}
-          <TheadComponent
-            className={classnames(this.props.theadClassName)}
-            style={this.props.theadStyle}
-          >
-            <TrComponent
-              className={this.props.trClassName}
-              style={this.props.trStyle}
-            >
-              {decoratedColumns.map((column, i) => {
-                const sort = sorting.find(d => d.id === column.id)
-                const show = typeof column.show === 'function' ? column.show() : column.show
-                return (
-                  <ThComponent
-                    key={i}
-                    className={classnames(
-                      this.props.thClassname,
-                      column.headerClassName,
-                      sort ? (sort.asc ? '-sort-asc' : '-sort-desc') : '',
-                      {
-                        '-cursor-pointer': column.sortable,
-                        '-hidden': !show
-                      }
-                    )}
-                    style={Object.assign({}, this.props.thStyle, column.headerStyle)}
-                    toggleSort={(e) => {
-                      column.sortable && this.sortColumn(column, e.shiftKey)
-                    }}
-                  >
-                    <div
-                      className={classnames(column.headerInnerClassName, '-th-inner')}
-                      style={Object.assign({}, column.headerInnerStyle, {
-                        minWidth: column.minWidth + 'px'
-                      })}
-                    >
-                      {typeof column.header === 'function' ? (
-                        <column.header
-                          data={this.props.data}
-                          column={column}
-                        />
-                      ) : column.header}
-                    </div>
-                  </ThComponent>
-                )
-              })}
-            </TrComponent>
-          </TheadComponent>
-          <TbodyComponent
-            className={classnames(this.props.tbodyClassName)}
-            style={this.props.tbodyStyle}
-          >
-            {pageRows.map((row, i) => {
-              const rowInfo = {
-                row: row.__original,
-                rowValues: row,
-                index: row.__index,
-                viewIndex: i
-              }
-              return (
-                <TrComponent
-                  key={i}
-                  className={classnames(this.props.trClassName, this.props.trClassCallback(rowInfo))}
-                  style={Object.assign({}, this.props.trStyle, this.props.trStyleCallback(rowInfo))}
-                >
-                  {decoratedColumns.map((column, i2) => {
-                    const Cell = column.render
-                    const show = typeof column.show === 'function' ? column.show() : column.show
-                    return (
-                      <TdComponent
-                        key={i2}
-                        className={classnames(column.className, {hidden: !show})}
-                        style={Object.assign({}, this.props.tdStyle, column.style)}
-                      >
-                        <div
-                          className={classnames(column.innerClassName, '-td-inner')}
-                          style={Object.assign({}, column.innerStyle, {
-                            minWidth: column.minWidth + 'px'
-                          })}
-                        >
-                          {typeof Cell === 'function' ? (
-                            <Cell
-                              {...rowInfo}
-                              value={rowInfo.rowValues[column.id]}
-                            />
-                          ) : typeof Cell !== 'undefined' ? Cell
-                          : rowInfo.rowValues[column.id]}
-                        </div>
-                      </TdComponent>
-                    )
-                  })}
-                </TrComponent>
-              )
-            })}
-            {padRows.map((row, i) => {
-              return (
-                <TrComponent
-                  key={i}
-                  className={classnames(this.props.trClassName, '-padRow')}
-                  style={this.props.trStyle}
-                >
-                  {decoratedColumns.map((column, i2) => {
-                    const show = typeof column.show === 'function' ? column.show() : column.show
-                    return (
-                      <TdComponent
-                        key={i2}
-                        className={classnames(column.className, {hidden: !show})}
-                        style={Object.assign({}, this.props.tdStyle, column.style)}
-                      >
-                        <div
-                          className={classnames(column.innerClassName, '-td-inner')}
-                          style={Object.assign({}, column.innerStyle, {
-                            minWidth: column.minWidth + 'px'
-                          })}
-                        >&nbsp;</div>
-                      </TdComponent>
-                    )
-                  })}
-                </TrComponent>
-              )
-            })}
-          </TbodyComponent>
-        </TableComponent>
-        {this.props.showPagination && (
-          <Pagination
-            currentPage={currentPage}
-            pagesLength={pagesLength}
-            pageSize={pageSize}
-            showPageSizeOptions={this.props.showPageSizeOptions}
-            pageSizeOptions={this.props.pageSizeOptions}
-            showPageJump={this.props.showPageJump}
-            canPrevious={canPrevious}
-            canNext={canNext}
-            previousText={this.props.previousText}
-            nextText={this.props.nextText}
-            previousComponent={PreviousComponent}
-            nextComponent={NextComponent}
-            //
-            onChange={this.setPage}
-            onPageSizeChange={this.setPageSize}
-          />
-        )}
-        <LoadingComponent {...this.props} />
-      </div>
-    )
-  },
-  // User actions
-  setPage (page) {
-    this.setState({
-      page
-    }, () => {
-      this.fireOnChange()
-    })
-  },
-  setPageSize (pageSize) {
-    const currentPageSize = this.getStateOrProp('pageSize')
-    const currentPage = this.getPropOrState('page')
-    const currentRow = currentPageSize * currentPage
-    const page = Math.floor(currentRow / pageSize)
-    this.setState({
-      pageSize,
-      page
-    }, () => {
-      this.fireOnChange()
-    })
-  },
-  sortColumn (column, additive) {
-    const existingSorting = this.getSorting()
-    let sorting = _.clone(this.state.sorting || [])
-    const existingIndex = sorting.findIndex(d => d.id === column.id)
-    if (existingIndex > -1) {
-      const existing = sorting[existingIndex]
-      if (existing.asc) {
-        existing.asc = false
-        if (!additive) {
-          sorting = [existing]
-        }
-      } else {
-        if (additive) {
-          sorting.splice(existingIndex, 1)
-        } else {
-          existing.asc = true
-          sorting = [existing]
-        }
-      }
-    } else {
-      if (additive) {
-        sorting.push({
-          id: column.id,
-          asc: true
-        })
-      } else {
-        sorting = [{
-          id: column.id,
-          asc: true
-        }]
-      }
-    }
-    const page = (existingIndex === 0 || (!existingSorting.length && sorting.length) || !additive) ? 0 : this.state.page
-    this.setState({
-      page,
-      sorting
-    }, () => {
-      this.fireOnChange()
-    })
-  }
-})
+export { useReactTable, usePagination, useFlexLayout, actions }
@@ -1,241 +0,0 @@
-@import 'nib'
-
-$easeOutQuad = cubic-bezier(0.250, 0.460, 0.450, 0.940)
-$easeOutBack = cubic-bezier(0.175,  0.885, 0.320, 1.275)
-
-.ReactTable
-  position:relative
-  table
-    width: 100%
-    border-collapse: collapse
-    border: 1px solid alpha(black, .1)
-    display: block
-    overflow-x: auto
-
-  .-td
-  .-th
-    &-inner
-      white-space: nowrap
-      text-overflow: ellipsis
-      padding: 7px 5px
-      overflow: hidden
-      z-index:0
-      transition: .3s ease
-      transition-property: width, min-width, padding, opacity
-
-  th
-  td
-    &:hover
-      .-td
-      .-th
-        &-inner
-          position:relative
-          overflow:visible
-          z-index:1
-          text-shadow:
-            0 0 1px white,
-            0 0 2px white,
-            1px 0 3px white,
-            1px 0 4px white,
-            2px 0 5px white,
-            2px 0 6px white,
-            3px 0 7px white,
-            3px 0 8px white,
-            4px 0 9px white,
-            4px 0 10px white,
-            5px 0 11px white,
-            5px 0 12px white,
-            6px 0 13px white,
-            6px 0 14px white,
-            7px 0 15px white,
-            7px 0 16px white,
-            8px 0 17px white,
-            8px 0 18px white,
-            9px 0 19px white,
-            9px 0 20px white
-
-          > *
-            text-shadow: none
-
-    &.-hidden
-      border:0 !important
-      opacity: 0 !important
-      .-th-inner
-      .-td-inner
-        width: 0 !important
-        min-width: 0 !important
-        padding: 0 !important
-
-  thead
-    box-shadow: 0px 5px 20px 0 alpha(black, .1)
-    z-index: 0
-
-    &.-headerGroups
-      border-bottom: 1px solid alpha(black, .05)
-
-      th
-      td
-        background: alpha(black, .03)
-
-    tr
-      text-align:center
-
-    th
-    td
-      width: 1%
-      background: white
-      font-weight:500
-      color: $darkColor
-      border-right: 1px solid alpha(black, .05)
-      transition box-shadow .3s $easeOutBack
-      box-shadow:inset 0 0 0 0 transparent
-      &.-sort-asc
-        box-shadow:inset 0 3px 0 0 alpha(black, .6)
-      &.-sort-desc
-        box-shadow:inset 0 -3px 0 0 alpha(black, .6)
-      &.-cursor-pointer
-        cursor: pointer
-
-  tbody
-    z-index:0
-    tr
-      border-bottom: solid 1px alpha(black, .05)
-      &:last-child
-        border-bottom: 0
-
-      &:first-child td
-        box-shadow: inset 0 20px 20px -20px alpha(black, .2)
-    td
-      border-right:1px solid alpha(black, .02)
-      &:last-child
-        border-right:0
-
-  &.striped
-    tbody tr:nth-child(even)
-      background: alpha(black, .03)
-  &.highlight
-    tbody tr:hover
-      background: alpha(black, .05)
-
-  .-pagination
-    width:100%
-    display:flex
-    justify-content: space-between
-    align-items: center
-    flex-wrap: wrap
-    padding-top:3px
-
-    .-btn
-      appearance:none
-      display:block
-      width:100%
-      border: 0
-      border-radius: 3px
-      padding: 6px
-      font-size: 1em
-      color: alpha(black, .6)
-      background: alpha(black, .1)
-      transition: all .1s ease
-      cursor: pointer
-      outline:none
-
-      &[disabled]
-        opacity: .5
-        cursor: default
-
-      &:not([disabled]):hover
-        background: alpha(black, .3)
-        color: white
-
-    .-previous
-    .-center
-    .-next
-      margin:3px 0
-
-    .-previous
-    .-next
-      flex: 1
-      text-align: center
-
-    .-center
-      flex: 1.5
-      text-align:center
-      margin-bottom:0
-      display: flex
-      flex-direction: row
-      flex-wrap: wrap
-      align-items: center
-      justify-content: space-around
-
-    .-pageInfo
-      display: inline-block
-      margin: 0 10px 3px
-      white-space: nowrap
-
-    .-pageJump
-      display:inline-block
-      input
-        width: 70px
-        text-align:center
-
-    .-pageSizeOptions
-      margin:0 10px 3px
-
-
-  .-loading
-    display:block
-    position:absolute
-    left:0
-    right:0
-    top:0
-    bottom:0
-    background: alpha(white, .8)
-    transition: all .3s ease
-    z-index: 2
-    opacity: 0
-    pointer-events: none
-
-    > div
-      position:absolute
-      display: block
-      text-align:center
-      width:100%
-      top:50%
-      left: 0
-      font-size: 15px
-      color: alpha(black, .6)
-      transform: translateY(-52%)
-      transition: all .3s $easeOutQuad
-
-    &.-active
-      opacity: 1
-      pointer-events: all
-      > div
-        transform: translateY(50%)
-
-  input
-  select
-    appearance: none
-    border: 1px solid rgba(0,0,0,0.1)
-    background: white
-    padding: 5px 7px
-    font-size: inherit
-    border-radius: 3px
-    font-weight: normal
-    outline:none
-
-  .select-wrap
-    position:relative
-    display:inline-block
-    select
-      padding: 5px 15px 5px 7px
-      min-width:100px
-    &:after
-      content: ''
-      position: absolute
-      right: 8px
-      top: 50%
-      transform: translate(0, -50%)
-      border-color: #999 transparent transparent
-      border-style: solid
-      border-width: 5px 5px 2.5px
@@ -1,121 +0,0 @@
-import React from 'react'
-import classnames from 'classnames'
-//
-// import _ from './utils'
-
-const defaultButton = (props) => (
-  <button {...props} className='-btn'>{props.children}</button>
-)
-
-export default React.createClass({
-  getInitialState () {
-    return {
-      page: this.props.currentPage
-    }
-  },
-  componentWillReceiveProps (nextProps) {
-    this.setState({page: nextProps.currentPage})
-  },
-  getSafePage (page) {
-    return Math.min(Math.max(page, 0), this.props.pagesLength - 1)
-  },
-  changePage (page) {
-    page = this.getSafePage(page)
-    this.setState({page})
-    this.props.onChange(page)
-  },
-  applyPage (e) {
-    e && e.preventDefault()
-    const page = this.state.page
-    this.changePage(page === '' ? this.props.currentPage : page)
-  },
-  render () {
-    const {
-      currentPage,
-      pagesLength,
-      showPageSizeOptions,
-      pageSizeOptions,
-      pageSize,
-      showPageJump,
-      canPrevious,
-      canNext,
-      onPageSizeChange
-    } = this.props
-
-    const PreviousComponent = this.props.previousComponent || defaultButton
-    const NextComponent = this.props.nextComponent || defaultButton
-
-    return (
-      <div
-        className={classnames(this.props.paginationClassName, '-pagination')}
-        style={this.props.paginationStyle}
-      >
-        <div className='-previous'>
-          <PreviousComponent
-            onClick={(e) => {
-              if (!canPrevious) return
-              this.changePage(currentPage - 1)
-            }}
-            disabled={!canPrevious}
-          >
-            {this.props.previousText}
-          </PreviousComponent>
-        </div>
-        <div className='-center'>
-          <span className='-pageInfo'>
-            Page {showPageJump ? (
-              <form className='-pageJump'
-                onSubmit={this.applyPage}
-              >
-                <input
-                  type={this.state.page === '' ? 'text' : 'number'}
-                  onChange={e => {
-                    const val = e.target.value
-                    const page = val - 1
-                    if (val === '') {
-                      return this.setState({page: val})
-                    }
-                    this.setState({page: this.getSafePage(page)})
-                  }}
-                  value={this.state.page === '' ? '' : this.state.page + 1}
-                  onBlur={this.applyPage}
-                />
-              </form>
-              ) : (
-                <span className='-currentPage'>{currentPage + 1}</span>
-            )} of <span className='-totalPages'>{pagesLength}</span>
-          </span>
-          {showPageSizeOptions && (
-            <span className='select-wrap -pageSizeOptions'>
-              <select
-                onChange={(e) => onPageSizeChange(Number(e.target.value))}
-                value={pageSize}
-              >
-                {pageSizeOptions.map((option, i) => {
-                  return (
-                    <option
-                      key={i}
-                      value={option}>
-                      {option} rows
-                    </option>
-                  )
-                })}
-              </select>
-            </span>
-          )}
-        </div>
-        <div className='-next'>
-          <NextComponent
-            onClick={(e) => {
-              if (!canNext) return
-              this.changePage(currentPage + 1)
-            }}
-            disabled={!canNext}
-          >
-            {this.props.nextText}
-          </NextComponent>
-        </div>
-      </div>
-    )
-  }
-})
@@ -0,0 +1,195 @@
+import { useMemo, useState } from 'react'
+import PropTypes from 'prop-types'
+
+import { getFirstDefined, sum } from './utils'
+
+const propTypes = {
+  defaultFlex: PropTypes.number,
+}
+
+export const actions = {}
+
+export default function useFlexLayout (api, props = {}) {
+  // Validate props
+  PropTypes.checkPropTypes(propTypes, props, 'property', 'useFlexLayout')
+
+  const {
+    hooks: {
+      getRowProps, getHeaderRowProps, getHeaderProps, getCellProps,
+    },
+    visibleColumns,
+  } = api
+
+  const { defaultFlex = 1 } = props
+
+  const [columnMeasurements, setColumnMeasurements] = useState({})
+
+  const rowStyles = useMemo(
+    () => {
+      let sumWidth = 0
+      visibleColumns.forEach(column => {
+        const { width, minWidth } = getSizesForColumn(
+          column,
+          defaultFlex,
+          undefined,
+          undefined,
+          api
+        )
+        if (width) {
+          sumWidth += width
+        } else if (minWidth) {
+          sumWidth += minWidth
+        } else {
+          sumWidth += defaultFlex
+        }
+      })
+
+      return {
+        style: {
+          display: 'flex',
+          minWidth: `${sumWidth}px`,
+        },
+      }
+    },
+    [visibleColumns]
+  )
+
+  getRowProps.push(row => rowStyles)
+  getHeaderRowProps.push(row => rowStyles)
+
+  getHeaderProps.push(column => ({
+    style: {
+      boxSizing: 'border-box',
+      ...getStylesForColumn(column, columnMeasurements, defaultFlex, api),
+    },
+    // [refKey]: el => {
+    //   renderedCellInfoRef.current[key] = {
+    //     column,
+    //     el
+    //   };
+    // },
+  }))
+
+  getCellProps.push(cell => ({
+    style: {
+      display: 'block',
+      boxSizing: 'border-box',
+      ...getStylesForColumn(cell.column, columnMeasurements, defaultFlex, undefined, api),
+    },
+    // [refKey]: el => {
+    //   renderedCellInfoRef.current[columnPathStr] = {
+    //     column,
+    //     el
+    //   };
+    // }
+  }))
+
+  return {
+    rowStyles,
+  }
+}
+
+function getStylesForColumn (column, columnMeasurements, defaultFlex, api) {
+  const { flex, width, maxWidth } = getSizesForColumn(column, columnMeasurements, defaultFlex, api)
+
+  return {
+    flex: `${flex} 0 auto`,
+    width: `${width}px`,
+    maxWidth: `${maxWidth}px`,
+  }
+}
+
+function getSizesForColumn (
+  {
+    columns, id, width, minWidth, maxWidth,
+  },
+  columnMeasurements,
+  defaultFlex,
+  api
+) {
+  if (columns) {
+    columns = columns
+      .map(column => getSizesForColumn(column, columnMeasurements, defaultFlex, api))
+      .filter(Boolean)
+
+    if (!columns.length) {
+      return false
+    }
+
+    const flex = sum(columns.map(col => col.flex))
+    const width = sum(columns.map(col => col.width))
+    const maxWidth = sum(columns.map(col => col.maxWidth))
+
+    return {
+      flex,
+      width,
+      maxWidth,
+    }
+  }
+
+  return {
+    flex: width ? 0 : defaultFlex,
+    width:
+      width === 'auto'
+        ? columnMeasurements[id] || defaultFlex
+        : getFirstDefined(width, minWidth, defaultFlex),
+    maxWidth,
+  }
+}
+
+// const resetRefs = () => {
+//   if (debug) console.info("resetRefs");
+//   renderedCellInfoRef.current = {};
+// };
+
+// const calculateAutoWidths = () => {
+//   RAF(() => {
+//     const newColumnMeasurements = {};
+//     Object.values(renderedCellInfoRef.current).forEach(({ column, el }) => {
+//       if (!el) {
+//         return;
+//       }
+
+//       let measurement = 0;
+
+//       const measureChildren = children => {
+//         if (children) {
+//           [].slice.call(children).forEach(child => {
+//             measurement = Math.max(
+//               measurement,
+//               Math.ceil(child.offsetWidth) || 0
+//             );
+//             measureChildren(child.children);
+//           });
+//         }
+//         return measurement;
+//       };
+
+//       const parentDims = getElementDimensions(el);
+//       measureChildren(el.children);
+
+//       newColumnMeasurements[column.id] = Math.max(
+//         newColumnMeasurements[column.id] || 0,
+//         measurement + parentDims.paddingLeft + parentDims.paddingRight
+//       );
+//     });
+
+//     const oldKeys = Object.keys(columnMeasurements);
+//     const newKeys = Object.keys(newColumnMeasurements);
+
+//     const needsUpdate =
+//       oldKeys.length !== newKeys.length ||
+//       oldKeys.some(key => {
+//         return columnMeasurements[key] !== newColumnMeasurements[key];
+//       });
+
+//     if (needsUpdate) {
+//       setState(old => {
+//         return {
+//           ...old,
+//           columnMeasurements: newColumnMeasurements
+//         };
+//       }, actions.updateAutoWidth);
+//     }
+//   });
+// };
@@ -0,0 +1,155 @@
+import { useMemo, useState, useLayoutEffect } from 'react'
+import PropTypes from 'prop-types'
+
+import { warnUnknownProps } from './utils'
+import useControlledState from './hooks/useControlledState'
+
+const propTypes = {
+  defaultPageSize: PropTypes.number,
+  defaultPageIndex: PropTypes.number,
+  pageSize: PropTypes.number,
+  pages: PropTypes.number,
+  pageIndex: PropTypes.number,
+  onStateChange: PropTypes.func,
+  stateReducer: PropTypes.func,
+  subRowsKey: PropTypes.string,
+  debug: PropTypes.bool,
+}
+
+export const actions = {
+  pageChange: '__pageChange__',
+}
+
+export default function usePagination (
+  {
+    debug: parentDebug, rows, prepareRows, groupedRows, sortedRows, filteredRows,
+  },
+  props = {}
+) {
+  // Validate props
+  PropTypes.checkPropTypes(propTypes, props, 'property', 'usePagination')
+
+  // Destructure props
+  const {
+    defaultPageSize = 10,
+    defaultPageIndex = 0,
+    pageSize: userPageSize,
+    pageIndex: userPageIndex,
+    state: userState,
+    manualPagination,
+    pageCount: userPageCount,
+    pageOptions: userPageOptions,
+    debug = parentDebug,
+    ...rest
+  } = props
+
+  warnUnknownProps(rest)
+
+  const defaultState = useState({})
+  const localState = userState || defaultState
+
+  // Build the controllable state
+  const [{ pageSize, pageIndex }, setState] = useControlledState(
+    localState,
+    {
+      pageSize: defaultPageSize,
+      pageIndex: defaultPageIndex,
+    },
+    {
+      pageSize: userPageSize,
+      pageIndex: userPageIndex,
+    }
+  )
+
+  useLayoutEffect(
+    () => {
+      if (manualPagination) {
+        return
+      }
+      setState(
+        old => ({
+          ...old,
+          pageIndex: 0,
+        }),
+        actions.pageChange
+      )
+    },
+    [groupedRows, sortedRows, filteredRows]
+  )
+
+  const { pages, pageCount } = useMemo(
+    () => {
+      if (manualPagination) {
+        return {
+          pages: [rows],
+          pageCount: userPageCount,
+        }
+      }
+      if (debug) console.info('getPages')
+
+      // Create a new pages with the first page ready to go.
+      const pages = rows.length ? [] : [[]]
+
+      // Start the pageIndex and currentPage cursors
+      let cursor = 0
+      while (cursor < rows.length) {
+        const end = cursor + pageSize
+        pages.push(rows.slice(cursor, end))
+        cursor = end
+      }
+
+      const pageCount = pages.length
+
+      return {
+        pages,
+        pageCount,
+        pageOptions,
+      }
+    },
+    [rows, pageSize, userPageCount]
+  )
+
+  const pageOptions = [...new Array(pageCount)].map((d, i) => i)
+  const page = manualPagination ? rows : pages[pageIndex] || []
+  const canPreviousPage = pageIndex > 0
+  const canNextPage = pageIndex < pageCount - 1
+
+  const gotoPage = pageIndex => {
+    if (debug) console.info('gotoPage')
+    return setState(old => {
+      if (pageIndex < 0 || pageIndex > pageCount - 1) {
+        return old
+      }
+      return {
+        ...old,
+        pageIndex,
+      }
+    }, actions.pageChange)
+  }
+
+  const previousPage = () => gotoPage(pageIndex - 1)
+
+  const nextPage = () => gotoPage(pageIndex + 1)
+
+  const setPageSize = pageSize => {
+    setState(old => ({
+      ...old,
+      pageSize,
+    }))
+  }
+
+  prepareRows(page)
+
+  return {
+    pages,
+    pageIndex,
+    pageOptions,
+    page,
+    canPreviousPage,
+    canNextPage,
+    gotoPage,
+    previousPage,
+    nextPage,
+    setPageSize,
+  }
+}
@@ -0,0 +1,470 @@
+import { useState, useMemo, useRef } from 'react'
+import PropTypes from 'prop-types'
+//
+import {
+  defaultOrderByFn,
+  defaultSortByFn,
+  defaultGroupByFn,
+  defaultFilterFn,
+  flexRender,
+  findExpandedDepth,
+  applyHooks,
+  mergeProps,
+  warnUnknownProps,
+} from './utils'
+
+// Internal Hooks
+import useControlledState from './hooks/useControlledState'
+import useColumns from './hooks/useColumns'
+import useTableMethods from './hooks/useTableMethods'
+import useAccessedRows from './hooks/useAccessedRows'
+import useGroupedRows from './hooks/useGroupedRows'
+import useFilteredRows from './hooks/useFilteredRows'
+import useSortedRows from './hooks/useSortedRows'
+import useExpandedRows from './hooks/useExpandedRows'
+
+const defaultFlex = 1
+const renderErr =
+  'You must specify a render "type". This could be "Header", "Filter", or any other custom renderers you have set on your column.'
+
+export const actions = {
+  sortByChange: '__sortByChange',
+  updateAutoWidth: '__updateAutoWidth__',
+  toggleGroupBy: '__toggleGroupBy__',
+  toggleExpanded: '__toggleExpanded__',
+  setExpanded: '__setExpanded__',
+  setFilter: '__setFilter__',
+  setAllFilters: '__setAllFilters__',
+}
+
+const propTypes = {
+  // General
+  data: PropTypes.any,
+  columns: PropTypes.arrayOf(
+    PropTypes.shape({
+      aggregate: PropTypes.func,
+      filterFn: PropTypes.func,
+      filterAll: PropTypes.bool,
+      sortByFn: PropTypes.func,
+      resolvedDefaultSortDesc: PropTypes.bool,
+      canSortBy: PropTypes.bool,
+      canGroupBy: PropTypes.bool,
+      Cell: PropTypes.any,
+      Header: PropTypes.any,
+      Filter: PropTypes.any,
+    })
+  ),
+  defaultFilters: PropTypes.array,
+  defaultSortBy: PropTypes.array,
+  defaultGroupBy: PropTypes.array,
+
+  groupBy: PropTypes.array,
+  filters: PropTypes.array,
+  sortBy: PropTypes.array,
+
+  filterFn: PropTypes.func,
+  sortByFn: PropTypes.func,
+  orderByFn: PropTypes.func,
+  groupByFn: PropTypes.func,
+
+  manualGrouping: PropTypes.bool,
+  manualFilters: PropTypes.bool,
+  manualSorting: PropTypes.bool,
+
+  disableGrouping: PropTypes.bool,
+  disableFilters: PropTypes.bool,
+  disableSorting: PropTypes.bool,
+
+  defaultSortDesc: PropTypes.bool,
+  disableMultiSort: PropTypes.bool,
+  subRowsKey: PropTypes.string,
+  expandedKey: PropTypes.string,
+  userAggregations: PropTypes.object,
+
+  debug: PropTypes.bool,
+}
+
+export default function useReactTable (props) {
+  // Validate props
+  PropTypes.checkPropTypes(propTypes, props, 'property', 'useReactTable')
+
+  // Destructure props
+  const {
+    data = [],
+    state: userState,
+    columns: userColumns,
+    sortBy: userSortBy,
+    groupBy: userGroupBy,
+    filters: userFilters,
+    expanded: userExpanded,
+    defaultSortBy = [],
+    defaultGroupBy = [],
+    defaultFilters = {},
+    defaultExpanded = {},
+    manualGrouping,
+    manualFilters,
+    manualSorting,
+    disableSorting,
+    disableGrouping,
+    disableFilters,
+    defaultSortDesc,
+    disableMultiSort,
+    subRowsKey = 'subRows',
+    expandedKey = 'expanded',
+    filterFn = defaultFilterFn,
+    sortByFn = defaultSortByFn,
+    orderByFn = defaultOrderByFn,
+    groupByFn = defaultGroupByFn,
+    userAggregations = {},
+    debug,
+    ...rest
+  } = props
+
+  warnUnknownProps(rest)
+
+  const defaultState = useState({})
+
+  const localState = userState || defaultState
+
+  // Build the controllable state
+  const [{
+    sortBy, groupBy, filters, expanded,
+  }, setState] = useControlledState(
+    localState,
+    {
+      sortBy: defaultSortBy,
+      groupBy: defaultGroupBy,
+      filters: defaultFilters,
+      expanded: defaultExpanded,
+    },
+    {
+      sortBy: userSortBy,
+      groupBy: userGroupBy,
+      filters: userFilters,
+      expanded: userExpanded,
+    }
+  )
+
+  const expandedDepth = findExpandedDepth(expanded)
+  const renderedCellInfoRef = useRef({})
+
+  // Build the base column
+  let { columns, headerGroups, headers } = useColumns({
+    debug,
+    groupBy,
+    userColumns,
+    defaultFlex,
+    renderedCellInfoRef,
+    disableSorting,
+    disableGrouping,
+    disableFilters,
+  })
+
+  // Use data and columns as memoization
+  const accessedRows = useAccessedRows({
+    debug,
+    data,
+    columns,
+    subRowsKey,
+  })
+
+  // Use rows and groupBy as memoization for row grouping
+  const groupedRows = useGroupedRows({
+    debug,
+    rows: accessedRows,
+    groupBy,
+    columns,
+    groupByFn,
+    manualGrouping,
+    userAggregations,
+  })
+
+  const filteredRows = useFilteredRows({
+    debug,
+    rows: groupedRows,
+    filters,
+    columns,
+    filterFn,
+    manualFilters,
+  })
+
+  const sortedRows = useSortedRows({
+    debug,
+    rows: filteredRows,
+    sortBy,
+    columns,
+    orderByFn,
+    sortByFn,
+    manualSorting,
+  })
+
+  const rows = useExpandedRows({
+    debug,
+    rows: sortedRows,
+    expanded,
+    expandedKey,
+    columns,
+    groupBy,
+    setState,
+    actions,
+  })
+
+  // Mutate columns to reflect sorting state
+  columns.forEach(column => {
+    const { id } = column
+    column.sorted = sortBy.find(d => d.id === id)
+    column.sortedIndex = sortBy.findIndex(d => d.id === id)
+    column.sortedDesc = column.sorted ? column.sorted.desc : undefined
+    column.filterVal = filters[id]
+  })
+
+  // Public API
+
+  const {
+    toggleExpandedByPath,
+    toggleSortByID,
+    toggleGroupBy,
+    setFilter,
+    setAllFilters,
+  } = useTableMethods({
+    debug,
+    setState,
+    actions,
+    groupBy,
+    columns,
+    defaultSortDesc,
+    filters,
+  })
+
+  const state = {
+    // State
+    columns,
+    expandedDepth,
+    accessedRows,
+    groupedRows,
+    filteredRows,
+    sortedRows,
+    rows,
+    headerGroups,
+    renderedCellInfoRef,
+    disableMultiSort,
+
+    // Controllable state
+    groupBy,
+    filters,
+    sortBy,
+    expanded,
+  }
+
+  const api = {
+    // State manager,
+    ...state,
+
+    // Methods
+    toggleExpandedByPath,
+    toggleSortByID,
+    toggleGroupBy,
+    setFilter,
+    setAllFilters,
+  }
+
+  columns.forEach(column => attachApi(column, api))
+  headers.forEach(header => attachApi(header, api))
+
+  const visibleColumns = columns.filter(column => {
+    column.visible = typeof column.show === 'function' ? column.show(state) : !!column.show
+    return column.visible
+  })
+
+  state.visibleColumns = visibleColumns
+  api.visibleColumns = visibleColumns
+
+  api.hooks = {
+    getTableProps: [],
+    getRowProps: [],
+    getHeaderRowProps: [],
+    getCellProps: [],
+    getHeaderProps: [],
+    getSortByToggleProps: [],
+    getGroupByToggleProps: [],
+  }
+
+  api.getTableProps = props => mergeProps(
+    {
+      style: {
+        overflowX: 'auto',
+      },
+    },
+    applyHooks(api.hooks.getTableProps),
+    props
+  )
+
+  api.getRowProps = props => mergeProps(applyHooks(api.hooks.getRowProps), props)
+
+  // Filter out hidden header groups or header groups that
+  // have no visible columns, then add the getRowProps method
+  headerGroups = useMemo(
+    () =>
+      headerGroups.filter((headerGroup, i) => {
+        headerGroup.headers = headerGroup.headers.filter(header => {
+          const recurse = columns => columns.filter(column => {
+            if (column.columns) {
+              return recurse(column.columns)
+            }
+            return column.visible
+          }).length
+          if (header.columns) {
+            return recurse(header.columns)
+          }
+          return header.visible
+        })
+
+        if (headerGroup.headers.length) {
+          headerGroup.getRowProps = (props = {}) => mergeProps(
+            {
+              key: [`header${i}`].join('_'),
+            },
+            applyHooks(api.hooks.getHeaderRowProps, headerGroup),
+            props
+          )
+          return true
+        }
+
+        return false
+      }),
+    [headerGroups]
+  )
+
+  // A function that mutates and prepares page rows with methods
+  api.prepareRows = rows => {
+    rows.forEach((row, i) => {
+      const { path } = row
+      row.getRowProps = props => mergeProps(
+        { key: ['row', i].join('_') },
+        applyHooks(api.hooks.getRowProps, row),
+        props
+      )
+
+      row.toggleExpanded = set => toggleExpandedByPath(path, set)
+
+      row.cells = row.cells.filter(cell => cell.column.visible);
+      [row.groupByCell, ...row.cells].forEach(cell => {
+        if (!cell) {
+          return
+        }
+
+        const { column } = cell
+
+        cell.getCellProps = props => {
+          const columnPathStr = [i, column.id].join('_')
+          return mergeProps(
+            {
+              key: ['cell', columnPathStr].join('_'),
+            },
+            applyHooks(api.hooks.getCellProps, cell),
+            props
+          )
+        }
+
+        cell.render = (type, userProps = {}) => {
+          if (!type) {
+            throw new Error(
+              'You must specify a render "type". This could be "Cell", "Header", "Filter", "Aggregated" or any other custom renderers you have set on your column.'
+            )
+          }
+          return flexRender(column[type], {
+            ...api,
+            ...cell,
+            ...userProps,
+          })
+        }
+      })
+    })
+  }
+
+  const makeHook = api => {
+    api.hook = (hook, ...args) => {
+      const result = hook(api, ...args) || {}
+      const newApi = {
+        ...api,
+        ...result,
+      }
+      makeHook(newApi)
+      return newApi
+    }
+  }
+
+  makeHook(api)
+
+  return api
+}
+
+function attachApi (column, api) {
+  const {
+    id, canSortBy, canGroupBy, canFilter,
+  } = column
+  const { toggleSortByID, toggleGroupBy, setFilter } = api
+
+  column.render = (type, userProps = {}) => {
+    if (!type) {
+      throw new Error(renderErr)
+    }
+    return flexRender(column[type], {
+      ...api,
+      ...column,
+      ...userProps,
+    })
+  }
+
+  if (canSortBy) {
+    column.toggleSortBy = (desc, multi) => toggleSortByID(id, desc, multi)
+  }
+  if (canGroupBy) {
+    column.toggleGroupBy = () => toggleGroupBy(id)
+  }
+  if (canFilter) {
+    column.setFilter = val => setFilter(id, val)
+  }
+
+  column.getSortByToggleProps = props => mergeProps(
+    {
+      onClick: canSortBy
+        ? e => {
+          e.persist()
+          column.toggleSortBy(undefined, !api.disableMultiSort && e.shiftKey)
+        }
+        : undefined,
+      style: {
+        cursor: canSortBy ? 'pointer' : undefined,
+      },
+      title: 'Toggle SortBy',
+    },
+    applyHooks(api.hooks.getSortByToggleProps, column),
+    props
+  )
+
+  column.getGroupByToggleProps = props => mergeProps(
+    {
+      onClick: canGroupBy
+        ? e => {
+          e.persist()
+          column.toggleGroupBy()
+        }
+        : undefined,
+      style: {
+        cursor: canGroupBy ? 'pointer' : undefined,
+      },
+      title: 'Toggle GroupBy',
+    },
+    applyHooks(api.hooks.getGroupByToggleProps, column),
+    props
+  )
+
+  column.getHeaderProps = props => mergeProps(
+    {
+      key: ['header', column.id].join('_'),
+    },
+    applyHooks(api.hooks.getHeaderProps, column),
+    props
+  )
+}
@@ -1,95 +1,178 @@
-export default {
-  get,
-  takeRight,
-  last,
-  orderBy,
-  range,
-  clone,
-  remove,
-  getFirstDefined
-}
+import React from 'react'

-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 get (a, b) {
-  if (isArray(b)) {
-    b = b.join('.')
+export function getBy (obj, path, def) {
+  if (!path) {
+    return obj
  }
-  return b
-    .replace('[', '.').replace(']', '')
-    .split('.')
-    .reduce(
-      function (obj, property) {
-        return obj[property]
-      }, a
-    )
-}
-
-function takeRight (arr, n) {
-  const start = n > arr.length ? 0 : arr.length - n
-  return arr.slice(start)
-}
-
-function last (arr) {
-  return arr[arr.length - 1]
-}
-
-function range (n) {
-  const arr = []
-  for (let i = 0; i < n; i++) {
-    arr.push(n)
+  const pathObj = makePathArray(path)
+  let val
+  try {
+    val = pathObj.reduce((cursor, pathPart) => cursor[pathPart], obj)
+  } catch (e) {
+    // continue regardless of error
  }
-  return arr
+  return typeof val !== 'undefined' ? val : def
 }

-function orderBy (arr, funcs, dirs) {
-  return arr.sort((a, b) => {
-    for (let i = 0; i < funcs.length; i++) {
-      const comp = funcs[i]
-      const ca = comp(a)
-      const cb = comp(b)
+export function defaultOrderByFn (arr, funcs, dirs) {
+  return [...arr].sort((rowA, rowB) => {
+    for (let i = 0; i < funcs.length; i += 1) {
+      const sortFn = funcs[i]
      const desc = dirs[i] === false || dirs[i] === 'desc'
-      if (ca > cb) {
-        return desc ? -1 : 1
-      }
-      if (ca < cb) {
-        return desc ? 1 : -1
+      const sortInt = sortFn(rowA, rowB)
+      if (sortInt !== 0) {
+        return desc ? -sortInt : sortInt
      }
    }
-    return 0
+    return dirs[0] ? rowA.index - rowB.index : rowB.index - rowA.index
  })
 }

-function clone (a) {
-  return JSON.parse(JSON.stringify(a, function (key, value) {
-    if (typeof value === 'function') {
-      return value.toString()
-    }
-    return value
-  }))
+export function defaultSortByFn (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 defer to the next
+  // sorting mechanism or eventually the columns index via the orderByFn
+  return 0
 }

-// ########################################################################
-// Helpers
-// ########################################################################
-
-function isArray (a) {
-  return Array.isArray(a)
-}
-
-function getFirstDefined (...args) {
-  for (var i = 0; i < args.length; i++) {
+export function getFirstDefined (...args) {
+  for (let i = 0; i < args.length; i += 1) {
    if (typeof args[i] !== 'undefined') {
      return args[i]
    }
  }
 }
+
+export function defaultGroupByFn (rows, grouper) {
+  return rows.reduce((prev, row, i) => {
+    const resKey = typeof grouper === 'function' ? grouper(row.values, i) : row.values[grouper]
+    prev[resKey] = Array.isArray(prev[resKey]) ? prev[resKey] : []
+    prev[resKey].push(row)
+    return prev
+  }, {})
+}
+
+export function defaultFilterFn (row, id, value, column) {
+  return row.values[id] !== undefined
+    ? String(row.values[id])
+      .toLowerCase()
+      .includes(String(value).toLowerCase())
+    : true
+}
+
+export function setBy (obj = {}, path, value) {
+  const recurse = (obj, depth = 0) => {
+    const key = path[depth]
+    const target = typeof obj[key] !== 'object' ? {} : obj[key]
+    const subValue = depth === path.length - 1 ? value : recurse(target, depth + 1)
+    return {
+      ...obj,
+      [key]: subValue,
+    }
+  }
+
+  return recurse(obj)
+}
+
+export function getElementDimensions (element) {
+  const rect = element.getBoundingClientRect()
+  const style = window.getComputedStyle(element)
+  const margins = {
+    left: parseInt(style.marginLeft),
+    right: parseInt(style.marginRight),
+  }
+  const padding = {
+    left: parseInt(style.paddingLeft),
+    right: parseInt(style.paddingRight),
+  }
+  return {
+    left: Math.ceil(rect.left),
+    width: Math.ceil(rect.width),
+    outerWidth: Math.ceil(rect.width + margins.left + margins.right + padding.left + padding.right),
+    marginLeft: margins.left,
+    marginRight: margins.right,
+    paddingLeft: padding.left,
+    paddingRight: padding.right,
+    scrollWidth: element.scrollWidth,
+  }
+}
+
+export function flexRender (Comp, props) {
+  if (typeof Comp === 'function') {
+    return Object.getPrototypeOf(Comp).isReactComponent ? <Comp {...props} /> : Comp(props)
+  }
+  return Comp
+}
+
+export function findExpandedDepth (obj, depth = 1) {
+  return Object.values(obj).reduce((prev, curr) => {
+    if (typeof curr === 'object') {
+      return Math.max(prev, findExpandedDepth(curr, depth + 1))
+    }
+    return depth
+  }, 0)
+}
+
+export const mergeProps = (...groups) => {
+  let props = {}
+  groups.forEach(({ style = {}, className, ...rest } = {}) => {
+    props = {
+      ...props,
+      ...rest,
+      style: {
+        ...(props.style || {}),
+        ...style,
+      },
+      className: [props.className, className].filter(Boolean).join(' '),
+    }
+  })
+  return props
+}
+
+export const applyHooks = (hooks, ...args) =>
+  hooks.reduce((prev, next) => mergeProps(prev, next(...args)), {})
+
+export const warnUnknownProps = props => {
+  if (Object.keys(props).length) {
+    throw new Error(
+      `Unknown options passed to useReactTable:
+      
+${JSON.stringify(props, null, 2)}`
+    )
+  }
+}
+
+export function sum (arr) {
+  return arr.reduce((prev, curr) => prev + curr, 0)
+}
+
+function makePathArray (obj) {
+  return flattenDeep(obj)
+    .join('.')
+    .replace(/\[/g, '.')
+    .replace(/\]/g, '')
+    .split('.')
+}
+
+function flattenDeep (arr, newArr = []) {
+  if (!Array.isArray(arr)) {
+    newArr.push(arr)
+  } else {
+    for (let i = 0; i < arr.length; i += 1) {
+      flattenDeep(arr[i], newArr)
+    }
+  }
+  return newArr
+}