v7.0.0-rc.5

The wrong variable was being checked against `undefined`, so the row was
always being toggled, rather than taking the parameter into account.

.size-snapshot.json

@@ -1,20 +1,20 @@
 {
   "dist/index.js": {
-    "bundled": 101464,
-    "minified": 49540,
-    "gzipped": 12771
+    "bundled": 100428,
+    "minified": 47447,
+    "gzipped": 12335
   },
   "dist/index.es.js": {
-    "bundled": 100408,
-    "minified": 48597,
-    "gzipped": 12591,
+    "bundled": 99612,
+    "minified": 46722,
+    "gzipped": 12189,
     "treeshaked": {
       "rollup": {
-        "code": 78,
+        "code": 80,
         "import_statements": 21
       },
       "webpack": {
-        "code": 14193
+        "code": 8457
       }
     }
   }

CHANGELOG.md

@@ -1,3 +1,39 @@
+## 7.0.0-rc.4
+
+- A maintenance release, purely intended to update the @latest tag (which was overwritten by a v6 publish)
+
+## 7.0.0-rc.3
+
+- Fixed an issue where `column.clearSortBy` would crash
+
+## 7.0.0-rc.2
+
+- `reducerHandlers` has been deprecated in favor of the new `stateReducers` hook.
+  - The `previousState` and `instanceRef` are now both generally available in state reducers for convenience.
+  - The global action property `action.instanceRef` has been deprecated.
+- The `reducer` option has been renamed to `stateReducer` and in addition to passing a single reducer function now also supports passing an array of reducers
+- Renamed `manualSorting` to be `manualSortBy` to be consistent with other naming conventions
+- Removed the `getResetPageDeps` option in favor of the new `autoResetPage` option.
+- Removed the `getResetFilterDeps` option in favor of the new `autoResetFilters` option.
+- Removed the `getResetSortByDeps` option in favor of the new `autoResetSortBy` option.
+- Removed the `getResetGroupByDeps` option in favor of the new `autoResetGroupBy` option.
+- Removed the `getResetExpandedDeps` option in favor of the new `autoResetExpanded` option.
+- Added a new exported utility called `useAsyncDebounce` to aid with external async side-effects.
+- A new `useGetLatest` hook is used internally to track latest instances in a less ref-driven and verbose way.
+- A new `useMountedLayoutEffect` hooks is now used internally to handle post-mount side-effects, mostly dealing with autoReset functionality
+- Plugin hooks are now "consumed" using an internal `useConsumeHookGetter` hook. When they are consumed, they can no longer be manipulated past that point in the table lifecycle. This should help ensure people are using them in a relatively safe order with consistent expectations.
+- Drastically "reduced" the reducer logic itself to be easier to understand and to be a stable reference for the life of the table. This change also means that the reducer must no longer be double-run/back-compared by React for changes in closure, thus actions and stateReducers (including user state reducers) will only fire once per action.
+- Removed `debug` and related logging. It has been somewhat useful during development, but is now very noisy in the code. We can debug lifecycle and performance as needed from here on out.
+- Removed unnecessary exports from `./utils.js` and moved all intentionally exported utilities to a new `./publicUtils.js` file.
+
+## 7.0.0-rc.1
+
+- Minor regex optimizations during row path creation
+
+## 7.0.0-rc.0
+
+- Added the support for the `Footer` renderer, `column.getFooterProps`, `footerGroups` and `footerGroup.getFooterProps`
+
 ## 7.0.0-beta.28
 
 - Added the `useColumnVisibility` plugin as a core plugin along with several new instance and column-level methods to control column visibility

README.md

@@ -42,7 +42,7 @@ Enjoy this library? Try them all! [React Query](https://github.com/tannerlinsley
 - [Installation](./docs/installation.md) - Walk through how to install React Table
 - [Concepts](./docs/concepts.md) - Read how React Table works and how you can use it better
 - [Examples](./docs/examples.md) - Experience and learn from some examples and guides of how to use React Table and implement common patterns
-- [API](./docs/api.md) - Get to know React Table's API
+- [API](./docs/api/README.md) - Get to know React Table's API
 - [FAQ](./docs/faq.md) - Learn how to use React Table for specific challenges and tasks
 - [Previous Versions](#previous-versions)
 - [Contributing](./CONTRIBUTING.md) - Become familiar with how to contribute back to React Table
@@ -182,6 +182,7 @@ This library is being built and maintained by me, @tannerlinsley and I am always
         <li>Jordan Soltman</li>
         <li>Robert Tajnšek</li>
         <li>Pekka Tapani</li>
+        <li>Eric Lanehart (@pushred)</li>
         </ul>
       </td>
       <td>

docs/api/README.md

@@ -5,7 +5,7 @@ React Table uses React Hooks both internally and externally for almost all of it
 React Table is essentially a compatible collection of **custom React hooks**:
 
 - The primary React Table hook
-  - [`useTable`](./usetable.md)
+  - [`useTable`](./useTable.md)
 - Plugin Hooks
   - Core Plugin Hooks
     - [`useGroupBy`](./useGroupBy.md)

docs/api/useExpanded.md

@@ -30,15 +30,12 @@ The following options are supported via the main options object passed to `useTa
   - Defaults to `true`
   - If set to `true`, expanded rows are rendered along with normal rows.
   - If set to `false`, expanded rows will only be available through their parent row. This could be useful if you are implementing a custom expanded row view.
-- `getResetExpandedDeps: Function(instance) => [...useEffectDependencies]`
-  - Optional
-  - Defaults to resetting the `expanded` state to `[]` when the dependencies below change
-    - ```js
-      const getResetExpandedDeps = ({ data }) => [data]
-      ```
-  - If set, the dependencies returned from this function will be used to determine when the effect to reset the `expanded` state is fired.
+- `autoResetExpanded: Boolean`
+  - Defaults to `true`
+  - When `true`, the `expanded` state will automatically reset if any of the following conditions are met:
+    - `data` is changed
   - To disable, set to `false`
-  - For more information see the FAQ ["How do I stop my table state from automatically resetting when my data changes?"](./faq#how-do-i-stop-my-table-state-from-automatically-resetting-when-my-data-changes)
+  - For more information see the FAQ ["How do I stop my table state from automatically resetting when my data changes?"](../faq.md#how-do-i-stop-my-table-state-from-automatically-resetting-when-my-data-changes)
 
 ### Instance Properties
 

docs/api/useFilters.md

@@ -0,0 +1,96 @@
+# `useFilters`
+
+- Plugin Hook
+- Optional
+
+`useFilters` is the hook that implements **row filtering**.
+
+### Table Options
+
+The following options are supported via the main options object passed to `useTable(options)`
+
+- `state.filters: Object<columnId: filterValue>`
+  - Must be **memoized**
+  - An object of columnId's and their corresponding filter values. This information is stored in state since the table is allowed to manipulate the filter through user interaction.
+- `initialState.filters`
+  - Identical to the `state.filters` option above
+- `manualFilters: Bool`
+  - Enables filter detection functionality, but does not automatically perform row filtering.
+  - Turn this on if you wish to implement your own row filter outside of the table (eg. server-side or manual row grouping/nesting)
+- `disableFilters: Bool`
+  - Disables filtering for every column in the entire table.
+- `defaultCanFilter: Bool`
+  - Optional
+  - Defaults to `false`
+  - If set to `true`, all columns will be filterable, regardless if they have a valid `accessor`
+- `filterTypes: Object<filterKey: filterType>`
+  - Must be **memoized**
+  - Allows overriding or adding additional filter types for columns to use. If a column's filter type isn't found on this object, it will default to using the built-in filter types.
+  - For more information on filter types, see Filtering
+- `autoResetFilters: Boolean`
+  - Defaults to `true`
+  - When `true`, the `filters` state will automatically reset if any of the following conditions are met:
+    - `data` is changed
+  - To disable, set to `false`
+  - For more information see the FAQ ["How do I stop my table state from automatically resetting when my data changes?"](./faq#how-do-i-stop-my-table-state-from-automatically-resetting-when-my-data-changes)
+
+### Column Options
+
+The following options are supported on any `Column` object passed to the `columns` options in `useTable()`
+
+- `Filter: Function | React.Component => JSX`
+  - **Required**
+  - Receives the table instance and column model as props
+  - Must return valid JSX
+  - This function (or component) is used to render this column's filter UI, eg.
+- `disableFilters: Bool`
+  - Optional
+  - If set to `true`, will disable filtering for this column
+- `defaultCanFilter: Bool`
+  - Optional
+  - Defaults to `false`
+  - If set to `true`, this column will be filterable, regardless if it has a valid `accessor`
+- `filter: String | Function`
+  - Optional
+  - Defaults to `text`
+  - The resolved function from the this string/function will be used to filter the this column's data.
+    - If a `string` is passed, the function with that name located on either the custom `filterTypes` option or the built-in filtering types object will be used. If
+    - If a `function` is passed, it will be used directly.
+  - For more information on filter types, see Filtering
+  - If a **function** is passed, it must be **memoized**
+
+### Instance Properties
+
+The following values are provided to the table `instance`:
+
+- `rows: Array<Row>`
+  - An array of **filtered** rows.
+- `preFilteredRows: Array<Row>`
+  - The array of rows **used right before filtering**.
+  - Among many other use-cases, these rows are directly useful for building option lists in filters, since the resulting filtered `rows` do not contain every possible option.
+- `setFilter: Function(columnId, filterValue) => void`
+  - An instance-level function used to update the filter value for a specific column.
+- `setAllFilters: Function(filtersObject) => void`
+  - An instance-level function used to update the values for **all** filters on the table, all at once.
+
+### Column Properties
+
+The following properties are available on every `Column` object returned by the table instance.
+
+- `canFilter: Bool`
+  - Denotes whether a column is filterable or not depending on if it has a valid accessor/data model or is manually disabled via an option.
+- `setFilter: Function(filterValue) => void`
+  - A column-level function used to update the filter value for this column
+- `filterValue: any`
+  - The current filter value for this column, resolved from the table state's `filters` object
+- `preFilteredRows: Array<row>`
+  - The array of rows that were originally passed to this columns filter **before** they were filtered.
+  - This array of rows can be useful if building faceted filter options.
+- `filteredRows: Array<row>`
+  - The resulting array of rows received from this columns filter **after** they were filtered.
+  - This array of rows can be useful if building faceted filter options.
+
+### Example
+
+- [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/filtering)
+- [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/filtering)

docs/api/usePagination.md

@@ -29,18 +29,13 @@ The following options are supported via the main options object passed to `useTa
 - `manualPagination: Bool`
   - Enables pagination functionality, but does not automatically perform row pagination.
   - Turn this on if you wish to implement your own pagination outside of the table (eg. server-side pagination or any other manual pagination technique)
-- `getResetPageDeps: Function(instance) => [...useEffectDependencies]`
-  - Optional
-  - Defaults to resetting the `pageIndex` to `0` when the dependencies below change
-    - ```js
-      const getResetPageDeps = ({
-        rows,
-        manualPagination,
-        state: { filters, groupBy, sortBy },
-      }) => [manualPagination ? null : rows, filters, groupBy, sortBy]
-      ```
-    - Note that if `manualPagination` is set to `true`, then the pageIndex should not be reset when `rows` change
-  - If set, the dependencies returned from this function will be used to determine when the effect to reset the `pageIndex` state is fired.
+- `autoResetPage: Boolean`
+  - Defaults to `true`
+  - When `true`, the `expanded` state will automatically reset if `manualPagination` is `false` and any of the following conditions are met:
+    - `data` is changed
+    - `manualSortBy` is `false` and `state.sortBy` is changed
+    - `manualFilters` is `false` and `state.filters` is changed
+    - `manualGroupBy` is `false` and `state.groupBy` is changed
   - To disable, set to `false`
   - For more information see the FAQ ["How do I stop my table state from automatically resetting when my data changes?"](./faq#how-do-i-stop-my-table-state-from-automatically-resetting-when-my-data-changes)
 - `paginateExpandedRows: Bool`

docs/api/useRowSelect.md

@@ -19,13 +19,10 @@ The following options are supported via the main options object passed to `useTa
   - Optional
   - Defaults to `isSelected`
   - If this key is found on the **original** data row, and it is true, this row will be manually selected
-- `getResetSelectedRowPathsDeps: Function(instance) => [...useEffectDependencies]`
-  - Optional
-  - Defaults to resetting the `expanded` state to `[]` when the dependencies below change
-    - ```js
-      const getResetSelectedRowPathsDeps = ({ rows }) => [rows]
-      ```
-  - If set, the dependencies returned from this function will be used to determine when the effect to reset the `selectedRowPaths` state is fired.
+- `autoResetSelectedRows: Boolean`
+  - Defaults to `true`
+  - When `true`, the `expanded` state will automatically reset if any of the following conditions are met:
+    - `data` is changed
   - To disable, set to `false`
   - For more information see the FAQ ["How do I stop my table state from automatically resetting when my data changes?"](./faq#how-do-i-stop-my-table-state-from-automatically-resetting-when-my-data-changes)
 

docs/api/useRowState.md

@@ -21,13 +21,10 @@ The following options are supported via the main options object passed to `useTa
   - Optional
   - This function may optionally return the initial state for a row.
   - If this function is defined, it will be passed a `Row` object, from which you can return a value to use as the initial state, eg. `row => row.original.initialState`
-- `getResetRowStateDeps: Function(instance) => [...useEffectDependencies]`
-  - Optional
-  - Defaults to resetting the `rowState` state to `{}` when the dependencies below change
-    - ```js
-      const getResetRowStateDeps = ({ data }) => [data]
-      ```
-  - If set, the dependencies returned from this function will be used to determine when the effect to reset the `rowState` state is fired.
+- `autoResetRowState: Boolean`
+  - Defaults to `true`
+  - When `true`, the `rowState` state will automatically reset if any of the following conditions are met:
+    - `data` is changed
   - To disable, set to `false`
   - For more information see the FAQ ["How do I stop my table state from automatically resetting when my data changes?"](./faq#how-do-i-stop-my-table-state-from-automatically-resetting-when-my-data-changes)
 

docs/api/useSortBy.md

@@ -46,10 +46,10 @@ The following options are supported via the main options object passed to `useTa
   - Must be **memoized**
   - Allows overriding or adding additional sort types for columns to use. If a column's sort type isn't found on this object, it will default to using the built-in sort types.
   - For more information on sort types, see Sorting
-- `getResetSortByDeps: Function(instance) => [...useEffectDependencies]`
-  - Optional
-  - Defaults to `false`
-  - If set, the dependencies returned from this function will be used to determine when the effect to reset the `sortBy` state is fired.
+- `autoResetSortBy: Boolean`
+  - Defaults to `true`
+  - When `true`, the `sortBy` state will automatically reset if any of the following conditions are met:
+    - `data` is changed
   - To disable, set to `false`
   - For more information see the FAQ ["How do I stop my table state from automatically resetting when my data changes?"](./faq#how-do-i-stop-my-table-state-from-automatically-resetting-when-my-data-changes)
 
@@ -125,100 +125,3 @@ The following properties are available on every `Column` object returned by the
 
 - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/sorting)
 - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/sorting)
-
-# `useFilters`
-
-- Plugin Hook
-- Optional
-
-`useFilters` is the hook that implements **row filtering**.
-
-### Table Options
-
-The following options are supported via the main options object passed to `useTable(options)`
-
-- `state.filters: Object<columnId: filterValue>`
-  - Must be **memoized**
-  - An object of columnId's and their corresponding filter values. This information is stored in state since the table is allowed to manipulate the filter through user interaction.
-- `initialState.filters`
-  - Identical to the `state.filters` option above
-- `manualFilters: Bool`
-  - Enables filter detection functionality, but does not automatically perform row filtering.
-  - Turn this on if you wish to implement your own row filter outside of the table (eg. server-side or manual row grouping/nesting)
-- `disableFilters: Bool`
-  - Disables filtering for every column in the entire table.
-- `defaultCanFilter: Bool`
-  - Optional
-  - Defaults to `false`
-  - If set to `true`, all columns will be filterable, regardless if they have a valid `accessor`
-- `filterTypes: Object<filterKey: filterType>`
-  - Must be **memoized**
-  - Allows overriding or adding additional filter types for columns to use. If a column's filter type isn't found on this object, it will default to using the built-in filter types.
-  - For more information on filter types, see Filtering
-- `getResetFiltersDeps: Function(instance) => [...useEffectDependencies]`
-  - Optional
-  - Defaults to `false`
-  - If set, the dependencies returned from this function will be used to determine when the effect to reset the `filters` state is fired.
-  - To disable, set to `false`
-  - For more information see the FAQ ["How do I stop my table state from automatically resetting when my data changes?"](./faq#how-do-i-stop-my-table-state-from-automatically-resetting-when-my-data-changes)
-
-### Column Options
-
-The following options are supported on any `Column` object passed to the `columns` options in `useTable()`
-
-- `Filter: Function | React.Component => JSX`
-  - **Required**
-  - Receives the table instance and column model as props
-  - Must return valid JSX
-  - This function (or component) is used to render this column's filter UI, eg.
-- `disableFilters: Bool`
-  - Optional
-  - If set to `true`, will disable filtering for this column
-- `defaultCanFilter: Bool`
-  - Optional
-  - Defaults to `false`
-  - If set to `true`, this column will be filterable, regardless if it has a valid `accessor`
-- `filter: String | Function`
-  - Optional
-  - Defaults to `text`
-  - The resolved function from the this string/function will be used to filter the this column's data.
-    - If a `string` is passed, the function with that name located on either the custom `filterTypes` option or the built-in filtering types object will be used. If
-    - If a `function` is passed, it will be used directly.
-  - For more information on filter types, see Filtering
-  - If a **function** is passed, it must be **memoized**
-
-### Instance Properties
-
-The following values are provided to the table `instance`:
-
-- `rows: Array<Row>`
-  - An array of **filtered** rows.
-- `preFilteredRows: Array<Row>`
-  - The array of rows **used right before filtering**.
-  - Among many other use-cases, these rows are directly useful for building option lists in filters, since the resulting filtered `rows` do not contain every possible option.
-- `setFilter: Function(columnId, filterValue) => void`
-  - An instance-level function used to update the filter value for a specific column.
-- `setAllFilters: Function(filtersObject) => void`
-  - An instance-level function used to update the values for **all** filters on the table, all at once.
-
-### Column Properties
-
-The following properties are available on every `Column` object returned by the table instance.
-
-- `canFilter: Bool`
-  - Denotes whether a column is filterable or not depending on if it has a valid accessor/data model or is manually disabled via an option.
-- `setFilter: Function(filterValue) => void`
-  - A column-level function used to update the filter value for this column
-- `filterValue: any`
-  - The current filter value for this column, resolved from the table state's `filters` object
-- `preFilteredRows: Array<row>`
-  - The array of rows that were originally passed to this columns filter **before** they were filtered.
-  - This array of rows can be useful if building faceted filter options.
-- `filteredRows: Array<row>`
-  - The resulting array of rows received from this columns filter **after** they were filtered.
-  - This array of rows can be useful if building faceted filter options.
-
-### Example
-
-- [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/filtering)
-- [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/filtering)

docs/api/useTable.md

@@ -132,7 +132,11 @@ The following properties are available on the table instance returned from `useT
 - `headerGroups: Array<HeaderGroup>`
   - An array of normalized header groups, each containing a flattened array of final column objects for that row.
   - **Some of these headers may be materialized as placeholders**
-  - See [Header Group Properties](#headergroup-properties) for more information
+  - See [HeaderGroup Properties](#headergroup-properties) for more information
+- `footerGroups: Array<HeaderGroup>`
+  - An array of normalized header groups, but in reverse order, each containing a flattened array of final column objects for that row.
+  - **Some of these headers may be materialized as placeholders**
+  - See [HeaderGroup Properties](#headergroup-properties) for more information
 - `headers: Array<Column>`
   - A **nested** array of final header objects, **similar in structure to the original columns configuration option, but rebuilt for ordering**
   - Each contains the headers that are displayed underneath it.
@@ -190,6 +194,11 @@ The following additional properties are available on every `headerGroup` object
   - This function is used to resolve any props needed for this header group's row.
   - You can use the `getHeaderGroupProps` hook to extend its functionality.
   - Custom props may be passed. **NOTE: Custom props will override built-in table props, so be careful!**
+- `getFooterGroupProps: Function(?props)`
+  - **Required**
+  - This function is used to resolve any props needed for this header group's footer row.
+  - You can use the `getFooterGroupProps` hook to extend its functionality.
+  - Custom props may be passed. **NOTE: Custom props will override built-in table props, so be careful!**
 
 ### Column Properties
 
@@ -203,7 +212,7 @@ The following properties are available on every `Column` object returned by the
 - `render: Function(type: String | Function | Component, ?props)`
   - This function is used to render content with the added context of a column.
   - The entire table `instance` will be passed to the renderer with the addition of a `column` property, containing a reference to the column
-  - If `type` is a string, will render using the `column[type]` renderer. React Table ships with default `Header` renderers. Other renderers like `Filter` are available via hooks like `useFilters`.
+  - If `type` is a string, will render using the `column[type]` renderer. React Table ships with default `Header` and `Footer` renderers. Other renderers like `Filter` and `Aggregated` are available via plugin hooks.
   - If a function or component is passed instead of a string, it will be be passed the table instance and column model as props and is expected to return any valid JSX.
 - `totalLeft: Int`
   - This is the total width in pixels of all columns to the left of this column
@@ -216,6 +225,11 @@ The following properties are available on every `Column` object returned by the
   - This function is used to resolve any props needed for this column's header cell.
   - You can use the `getHeaderProps` hook to extend its functionality.
   - Custom props may be passed. **NOTE: Custom props will override built-in table props, so be careful!**
+- `getFooterProps: Function(?props)`
+  - **Required**
+  - This function is used to resolve any props needed for this column's footer cell.
+  - You can use the `getFooterProps` hook to extend its functionality.
+  - Custom props may be passed. **NOTE: Custom props will override built-in table props, so be careful!**
 - `toggleHidden: Function(?hidden: Boolean) => void`
   - This function can be used to hide or show this column.
   - If no value is passed, the visibility of this column will be toggled.

docs/concepts.md

@@ -30,4 +30,4 @@ As of React Table v7, **you the developer** are responsible for rendering your o
 After reading about React Table's concepts, you should:
 
 - [Check Out Some Examples](./examples.md)
-- [Study the API](./api.md)
+- [Study the API](./api/README.md)

docs/examples.md

@@ -4,6 +4,9 @@
   - Basic
     - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/basic)
     - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/basic)
+  - Footers
+    - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/footers)
+    - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/footers)
   - Sorting
     - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/sorting)
     - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/sorting)
@@ -31,6 +34,9 @@
   - Column Ordering
     - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/column-ordering)
     - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/column-ordering)
+  - Column Hiding
+    - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/column-hiding)
+    - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/column-hiding)
   - Column Resizing
     - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/column-resizing)
     - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/column-resizing)

docs/faq.md

@@ -26,36 +26,96 @@ useTable({
 })
 ```
 
-**It's important that the state override is done within a `useMemo` call to prevent the state variable from changing on every render. It's also just as important that you always use the `state` in any memoization dependencies to ensure that you do not block normal state updates.**
+> **It's important that the state override is done within a `useMemo` call to prevent the state variable from changing on every render. It's also extremely important that you always use the `state` in any dependencies to ensure that you do not block normal state updates.**
+
+## How can I use the table state to fetch new data?
+
+When managing your data externally or asynchronously (eg. server-side pagination/sorting/grouping/etc), you will need to fetch new data as the internal table state changes. With React Hooks, this is fantastically easier than it was before now that we have the `React.useEffect` hook. We can use this hook to "watch" the table state for specific changes and use those effects to trigger fetches for new data (or synchronize any other state you may be managing externally from your table component):
+
+```js
+function Table({ data, onFetchData }) {
+  const {
+    state: { pageIndex, pageSize, sortBy, filters },
+  } = useTable({
+    data,
+  })
+
+  // When the these table states change, fetch new data!
+  React.useEffect(() => {
+    onFetchData({ pageIndex, pageSize, sortBy, filters })
+  }, [fetchData, pageIndex, pageSize, sortBy, filters])
+
+  return </>
+}
+```
+
+Using this approach, you can respond and trigger any type of side-effect using the table instance!
+
+## How can I debounce rapid table state changes?
+
+React Table has a few built-in side-effects of it's own (most of which are meant for resetting parts of the state when `data` changes). By default, these state side-effects are on and when their conditions are met, they immediately fire off actions that will manipulate the table state. Sometimes, this may result in multiple rapid rerenders (usually just 2, or one more than normal), and could cause any side-effects you have watching the table state to also fire multiple times in-a-row. To alleviate this edge-case, React Table exports a `useAsyncDebounce` function that will allow you to debounce rapid side-effects and only use the latest one.
+
+A good example of this when doing server-side pagination and sorting, a user changes the `sortBy` for a table and the `pageIndex` is automatically reset to `0` via an internal side effect. This would normally cause our effect below to fire 2 times, but with `useAsyncDebounce` we can make sure our data fetch function only gets called once:
+
+```js
+import { useTable, useAsyncDebounce } from 'react-table'
+
+function Table({ data, onFetchData }) {
+  const {
+    state: { pageIndex, pageSize, sortBy, filters },
+  } = useTable({
+    data,
+  })
+
+  // Debounce our onFetchData call for 100ms
+  const onFetchDataDebounced = useAsyncDebounce(onFetchData, 100)
+
+  // When the these table states changes, fetch new data!
+  React.useEffect(() => {
+    // Every change will call our debounced function
+    onFetchDataDebounced({ pageIndex, pageSize, sortBy, filters })
+    // Only the last call after the 100ms debounce is over will be fired!
+  }, [onFetchDataDebounced, pageIndex, pageSize, sortBy, filters])
+
+  return </>
+}
+```
 
 ## How do I stop my table state from automatically resetting when my data changes?
 
 Most plugins use state that _should_ normally reset when the data sources changes, but sometimes you need to suppress that from happening if you are filtering your data externally, or immutably editing your data while looking at it, or simply doing anything external with your data that you don't want to trigger a piece of table state to reset automatically.
 
-For those situations, each plugin provides options like `getResetPageDeps` or `getResetExpandedDeps`, so and an so forth. These functions are provided the table `instance` and allowed to return an array of variables that will be injected into the `React.useEffect`'s dependency array that is responsible for watching and resetting those states. By returning a new array in one of these arrays, you can either stop the automatic resets from being triggered, or even trigger them more based on what you are returning. You can also return `false` for any of these options to disable the automatic resets completely, or pass `undefined` to allow the default dependendies to be used.
+For those situations, each plugin provides a way to disable the state from automatically resetting internally when data or other dependencies for a piece of state change. By setting any of them to `false`, you can stop the automatic resets from being triggered.
 
-Here is an example of completely disabling the page from resetting when data changes:
+Here is an example of stopping basically every piece of state from changing as they normally do while we edit the `data` source for a table:
 
 ```js
 const [data, setData] = React.useState([])
 const skipPageResetRef = React.useRef()
 
 const updateData = newData => {
-  // When data gets updated with this function, disable the
-  // page from resetting
+  // When data gets updated with this function, set a flag
+  // to disable all of the auto resetting
   skipPageResetRef.current = true
 
   setData(newData)
 }
 
 React.useEffect(() => {
+  // After the table has updated, always remove the flag
   skipPageResetRef.current = false
 })
 
 useTable({
-  data,
-  getResetPageDeps: skipPageReset ? false : undefined,
+  ...
+  autoResetPage: !skipPageReset,
+  autoResetExpanded: !skipPageReset,
+  autoResetGroupBy: !skipPageReset,
+  autoResetSelectedRows: !skipPageReset,
+  autoResetSortBy: !skipPageReset,
+  autoResetFilters: !skipPageReset,
+  autoResetRowState: !skipPageReset,
 })
 ```
 
-<!-- ## How can I hide/show columns? -->
+Now, when we update our data, the above table states will not automatically reset!

examples/basic/yarn.lock

@@ -3652,16 +3652,16 @@ eslint-scope@^4.0.0, eslint-scope@^4.0.3:
     estraverse "^4.1.1"
 
 eslint-utils@^1.3.1:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-1.4.0.tgz#e2c3c8dba768425f897cf0f9e51fe2e241485d4c"
-  integrity sha512-7ehnzPaP5IIEh1r1tkjuIrxqhNkzUJa9z3R92tLJdZIVdWaczEhr3EbhGtsMrVxi1KeR8qA7Off6SWc5WNQqyQ==
+  version "1.4.3"
+  resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-1.4.3.tgz#74fec7c54d0776b6f67e0251040b5806564e981f"
+  integrity sha512-fbBN5W2xdY45KulGXmLHZ3c3FHfVYmKg0IrAKGOkT/464PQsx2UeIzfz1RmEci+KLm1bBaAzZAh8+/E+XAeZ8Q==
   dependencies:
-    eslint-visitor-keys "^1.0.0"
+    eslint-visitor-keys "^1.1.0"
 
-eslint-visitor-keys@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-1.0.0.tgz#3f3180fb2e291017716acb4c9d6d5b5c34a6a81d"
-  integrity sha512-qzm/XxIbxm/FHyH341ZrbnMUpe+5Bocte9xkmFMzPMjRaZMcXww+MpBptFvtU+79L362nqiLhekCxCxDPaUMBQ==
+eslint-visitor-keys@^1.0.0, eslint-visitor-keys@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-1.1.0.tgz#e2a82cea84ff246ad6fb57f9bde5b46621459ec2"
+  integrity sha512-8y9YjtM1JBJU/A9Kc+SbaOV4y29sSWckBwMHa+FGtVj5gN/sbnKDf6xJUl+8g7FAij9LVaP8C24DUiH/f/2Z9A==
 
 eslint@^5.16.0:
   version "5.16.0"
@@ -8087,10 +8087,10 @@ react-scripts@3.0.1:
   optionalDependencies:
     fsevents "2.0.6"
 
-react-table@next:
-  version "7.0.0-alpha.7"
-  resolved "https://registry.yarnpkg.com/react-table/-/react-table-7.0.0-alpha.7.tgz#0cb6da6f32adb397e68505b7cdd4880d15d73017"
-  integrity sha512-oXE9RRkE2CFk1OloNCSTPQ9qxOdujgkCoW5b/srbJsBog/ySkWuozBTQkxH1wGNmnSxGyTrTxJqXdXPQam7VAw==
+react-table@latest:
+  version "7.0.0-beta.28"
+  resolved "https://registry.yarnpkg.com/react-table/-/react-table-7.0.0-beta.28.tgz#f5cd37b09fdbc7f22f472d021c56637d9fae097c"
+  integrity sha512-Ym05FAFNPGU6cid3Uw2W2+tn3mfGqKkLs51dw5FAJyz3fFNV0/i/CrTzHXZbVDA/KO2KNFYUjKGQJxIiDbXb4w==
 
 react@^16.8.6:
   version "16.8.6"

examples/column-hiding/README.md

@@ -2,5 +2,5 @@ This project was bootstrapped with [Create React App](https://github.com/faceboo
 
 You can:
 
-- [Open this example in a new CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/basic)
+- [Open this example in a new CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/column-hiding)
 - `yarn` and `yarn start` to run and edit the example

examples/column-hiding/yarn.lock

@@ -3652,16 +3652,16 @@ eslint-scope@^4.0.0, eslint-scope@^4.0.3:
     estraverse "^4.1.1"
 
 eslint-utils@^1.3.1:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-1.4.0.tgz#e2c3c8dba768425f897cf0f9e51fe2e241485d4c"
-  integrity sha512-7ehnzPaP5IIEh1r1tkjuIrxqhNkzUJa9z3R92tLJdZIVdWaczEhr3EbhGtsMrVxi1KeR8qA7Off6SWc5WNQqyQ==
+  version "1.4.3"
+  resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-1.4.3.tgz#74fec7c54d0776b6f67e0251040b5806564e981f"
+  integrity sha512-fbBN5W2xdY45KulGXmLHZ3c3FHfVYmKg0IrAKGOkT/464PQsx2UeIzfz1RmEci+KLm1bBaAzZAh8+/E+XAeZ8Q==
   dependencies:
-    eslint-visitor-keys "^1.0.0"
+    eslint-visitor-keys "^1.1.0"
 
-eslint-visitor-keys@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-1.0.0.tgz#3f3180fb2e291017716acb4c9d6d5b5c34a6a81d"
-  integrity sha512-qzm/XxIbxm/FHyH341ZrbnMUpe+5Bocte9xkmFMzPMjRaZMcXww+MpBptFvtU+79L362nqiLhekCxCxDPaUMBQ==
+eslint-visitor-keys@^1.0.0, eslint-visitor-keys@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-1.1.0.tgz#e2a82cea84ff246ad6fb57f9bde5b46621459ec2"
+  integrity sha512-8y9YjtM1JBJU/A9Kc+SbaOV4y29sSWckBwMHa+FGtVj5gN/sbnKDf6xJUl+8g7FAij9LVaP8C24DUiH/f/2Z9A==
 
 eslint@^5.16.0:
   version "5.16.0"

examples/editable-data/src/App.js

@@ -102,7 +102,7 @@ function Table({ columns, data, updateMyData, skipPageReset }) {
       data,
       defaultColumn,
       // use the skipPageReset option to disable page resetting temporarily
-      getResetPageDeps: skipPageReset ? false : undefined,
+      autoResetPage: !skipPageReset,
       // updateMyData isn't part of the API, but
       // anything we put into these options will
       // automatically be available on the instance.

examples/footers/.babelrc

@@ -0,0 +1,4 @@
+{
+  "presets": ["react-app"],
+  "plugins": ["styled-components"]
+}

examples/footers/.env

@@ -0,0 +1 @@
+SKIP_PREFLIGHT_CHECK=true

examples/footers/.eslintrc

@@ -0,0 +1,7 @@
+{
+  "extends": ["react-app", "prettier"],
+  "rules": {
+    // "eqeqeq": 0,
+    // "jsx-a11y/anchor-is-valid": 0
+  }
+}

examples/footers/.gitignore

@@ -0,0 +1,23 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+
+# testing
+/coverage
+
+# production
+/build
+
+# misc
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*

examples/footers/.rescriptsrc.js

@@ -0,0 +1,29 @@
+const path = require('path')
+const resolveFrom = require('resolve-from')
+
+const fixLinkedDependencies = config => {
+  config.resolve = {
+    ...config.resolve,
+    alias: {
+      ...config.resolve.alias,
+      react$: resolveFrom(path.resolve('node_modules'), 'react'),
+      'react-dom$': resolveFrom(path.resolve('node_modules'), 'react-dom'),
+    },
+  }
+  return config
+}
+
+const includeSrcDirectory = config => {
+  config.resolve = {
+    ...config.resolve,
+    modules: [path.resolve('src'), ...config.resolve.modules],
+  }
+  return config
+}
+
+module.exports = [
+  ['use-babel-config', '.babelrc'],
+  ['use-eslint-config', '.eslintrc'],
+  fixLinkedDependencies,
+  // includeSrcDirectory,
+]

examples/footers/README.md

@@ -0,0 +1,6 @@
+This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app) and Rescripts.
+
+You can:
+
+- [Open this example in a new CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/footers)
+- `yarn` and `yarn start` to run and edit the example

examples/footers/package.json

@@ -0,0 +1,35 @@
+{
+  "private": true,
+  "scripts": {
+    "start": "rescripts start",
+    "build": "rescripts build",
+    "test": "rescripts test",
+    "eject": "rescripts eject"
+  },
+  "dependencies": {
+    "namor": "^1.1.2",
+    "react": "^16.8.6",
+    "react-dom": "^16.8.6",
+    "react-scripts": "3.0.1",
+    "react-table": "latest",
+    "styled-components": "^4.3.2"
+  },
+  "devDependencies": {
+    "@rescripts/cli": "^0.0.11",
+    "@rescripts/rescript-use-babel-config": "^0.0.8",
+    "@rescripts/rescript-use-eslint-config": "^0.0.9",
+    "babel-eslint": "10.0.1"
+  },
+  "browserslist": {
+    "production": [
+      ">0.2%",
+      "not dead",
+      "not op_mini all"
+    ],
+    "development": [
+      "last 1 chrome version",
+      "last 1 firefox version",
+      "last 1 safari version"
+    ]
+  }
+}

examples/footers/public/index.html

@@ -0,0 +1,38 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <link rel="shortcut icon" href="%PUBLIC_URL%/favicon.ico" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="theme-color" content="#000000" />
+    <!--
+      manifest.json provides metadata used when your web app is installed on a
+      user's mobile device or desktop. See https://developers.google.com/web/fundamentals/web-app-manifest/
+    -->
+    <link rel="manifest" href="%PUBLIC_URL%/manifest.json" />
+    <!--
+      Notice the use of %PUBLIC_URL% in the tags above.
+      It will be replaced with the URL of the `public` folder during the build.
+      Only files inside the `public` folder can be referenced from the HTML.
+
+      Unlike "/favicon.ico" or "favicon.ico", "%PUBLIC_URL%/favicon.ico" will
+      work correctly both with client-side routing and a non-root public URL.
+      Learn how to configure a non-root public URL by running `npm run build`.
+    -->
+    <title>React App</title>
+  </head>
+  <body>
+    <noscript>You need to enable JavaScript to run this app.</noscript>
+    <div id="root"></div>
+    <!--
+      This HTML file is a template.
+      If you open it directly in the browser, you will see an empty page.
+
+      You can add webfonts, meta tags, or analytics to this file.
+      The build step will place the bundled scripts into the <body> tag.
+
+      To begin the development, run `npm start` or `yarn start`.
+      To create a production bundle, use `npm run build` or `yarn build`.
+    -->
+  </body>
+</html>

examples/footers/public/manifest.json

@@ -0,0 +1,15 @@
+{
+  "short_name": "React App",
+  "name": "Create React App Sample",
+  "icons": [
+    {
+      "src": "favicon.ico",
+      "sizes": "64x64 32x32 24x24 16x16",
+      "type": "image/x-icon"
+    }
+  ],
+  "start_url": ".",
+  "display": "standalone",
+  "theme_color": "#000000",
+  "background_color": "#ffffff"
+}

examples/footers/src/App.js

@@ -0,0 +1,169 @@
+import React from 'react'
+import styled from 'styled-components'
+import { useTable } from 'react-table'
+
+import makeData from './makeData'
+
+const Styles = styled.div`
+  padding: 1rem;
+
+  table {
+    border-spacing: 0;
+    border: 1px solid black;
+
+    tr {
+      ${'' /* :first-child {
+        td {
+          border-top: 1px solid black;
+        }
+      } */}
+
+      :last-child {
+        td {
+          border-bottom: 0;
+        }
+      }
+    }
+
+    th,
+    td {
+      margin: 0;
+      padding: 0.5rem;
+      border-bottom: 1px solid black;
+      border-right: 1px solid black;
+
+      :last-child {
+        border-right: 0;
+      }
+    }
+
+    tfoot {
+      tr:first-child {
+        td {
+          border-top: 2px solid black;
+        }
+      }
+      font-weight: bolder;
+    }
+  }
+`
+
+function Table({ columns, data }) {
+  // Use the state and functions returned from useTable to build your UI
+  const {
+    getTableProps,
+    getTableBodyProps,
+    headerGroups,
+    footerGroups,
+    rows,
+    prepareRow,
+  } = useTable({
+    columns,
+    data,
+  })
+
+  // Render the UI for your table
+  return (
+    <table {...getTableProps()}>
+      <thead>
+        {headerGroups.map(group => (
+          <tr {...group.getHeaderGroupProps()}>
+            {group.headers.map(column => (
+              <th {...column.getHeaderProps()}>{column.render('Header')}</th>
+            ))}
+          </tr>
+        ))}
+      </thead>
+      <tbody {...getTableBodyProps()}>
+        {rows.map((row, i) => {
+          prepareRow(row)
+          return (
+            <tr {...row.getRowProps()}>
+              {row.cells.map(cell => {
+                return <td {...cell.getCellProps()}>{cell.render('Cell')}</td>
+              })}
+            </tr>
+          )
+        })}
+      </tbody>
+      <tfoot>
+        {footerGroups.map(group => (
+          <tr {...group.getFooterGroupProps()}>
+            {group.headers.map(column => (
+              <td {...column.getFooterProps()}>{column.render('Footer')}</td>
+            ))}
+          </tr>
+        ))}
+      </tfoot>
+    </table>
+  )
+}
+
+function App() {
+  const columns = React.useMemo(
+    () => [
+      {
+        Header: 'Name',
+        Footer: 'Name',
+        columns: [
+          {
+            Header: 'First Name',
+            accessor: 'firstName',
+            Footer: 'First Name',
+          },
+          {
+            Header: 'Last Name',
+            accessor: 'lastName',
+            Footer: 'Last Name',
+          },
+        ],
+      },
+      {
+        Header: 'Info',
+        Footer: 'Info',
+        columns: [
+          {
+            Header: 'Age',
+            accessor: 'age',
+            Footer: 'Age',
+          },
+          {
+            Header: 'Visits',
+            accessor: 'visits',
+            Footer: info => {
+              // Only calculate total visits if rows change
+              const total = React.useMemo(
+                () =>
+                  info.rows.reduce((sum, row) => row.values.visits + sum, 0),
+                [info.rows]
+              )
+
+              return <>Total: {total}</>
+            },
+          },
+          {
+            Header: 'Status',
+            accessor: 'status',
+            Footer: 'Status',
+          },
+          {
+            Header: 'Profile Progress',
+            accessor: 'progress',
+            Footer: 'Profile Progress',
+          },
+        ],
+      },
+    ],
+    []
+  )
+
+  const data = React.useMemo(() => makeData(20), [])
+
+  return (
+    <Styles>
+      <Table columns={columns} data={data} />
+    </Styles>
+  )
+}
+
+export default App

examples/footers/src/App.test.js

@@ -0,0 +1,9 @@
+import React from 'react'
+import ReactDOM from 'react-dom'
+import App from './App'
+
+it('renders without crashing', () => {
+  const div = document.createElement('div')
+  ReactDOM.render(<App />, div)
+  ReactDOM.unmountComponentAtNode(div)
+})

examples/footers/src/index.css

@@ -0,0 +1,13 @@
+body {
+  margin: 0;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
+    'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
+    sans-serif;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+code {
+  font-family: source-code-pro, Menlo, Monaco, Consolas, 'Courier New',
+    monospace;
+}

examples/footers/src/index.js

@@ -0,0 +1,6 @@
+import React from 'react'
+import ReactDOM from 'react-dom'
+import './index.css'
+import App from './App'
+
+ReactDOM.render(<App />, document.getElementById('root'))

examples/footers/src/makeData.js

@@ -0,0 +1,40 @@
+import namor from 'namor'
+
+const range = len => {
+  const arr = []
+  for (let i = 0; i < len; i++) {
+    arr.push(i)
+  }
+  return arr
+}
+
+const newPerson = () => {
+  const statusChance = Math.random()
+  return {
+    firstName: namor.generate({ words: 1, numbers: 0 }),
+    lastName: namor.generate({ words: 1, numbers: 0 }),
+    age: Math.floor(Math.random() * 30),
+    visits: Math.floor(Math.random() * 100),
+    progress: Math.floor(Math.random() * 100),
+    status:
+      statusChance > 0.66
+        ? 'relationship'
+        : statusChance > 0.33
+        ? 'complicated'
+        : 'single',
+  }
+}
+
+export default function makeData(...lens) {
+  const makeDataLevel = (depth = 0) => {
+    const len = lens[depth]
+    return range(len).map(d => {
+      return {
+        ...newPerson(),
+        subRows: lens[depth + 1] ? makeDataLevel(depth + 1) : undefined,
+      }
+    })
+  }
+
+  return makeDataLevel()
+}

examples/grouping/yarn.lock

@@ -3652,16 +3652,16 @@ eslint-scope@^4.0.0, eslint-scope@^4.0.3:
     estraverse "^4.1.1"
 
 eslint-utils@^1.3.1:
-  version "1.4.0"
-  resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-1.4.0.tgz#e2c3c8dba768425f897cf0f9e51fe2e241485d4c"
-  integrity sha512-7ehnzPaP5IIEh1r1tkjuIrxqhNkzUJa9z3R92tLJdZIVdWaczEhr3EbhGtsMrVxi1KeR8qA7Off6SWc5WNQqyQ==
+  version "1.4.3"
+  resolved "https://registry.yarnpkg.com/eslint-utils/-/eslint-utils-1.4.3.tgz#74fec7c54d0776b6f67e0251040b5806564e981f"
+  integrity sha512-fbBN5W2xdY45KulGXmLHZ3c3FHfVYmKg0IrAKGOkT/464PQsx2UeIzfz1RmEci+KLm1bBaAzZAh8+/E+XAeZ8Q==
   dependencies:
-    eslint-visitor-keys "^1.0.0"
+    eslint-visitor-keys "^1.1.0"
 
-eslint-visitor-keys@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-1.0.0.tgz#3f3180fb2e291017716acb4c9d6d5b5c34a6a81d"
-  integrity sha512-qzm/XxIbxm/FHyH341ZrbnMUpe+5Bocte9xkmFMzPMjRaZMcXww+MpBptFvtU+79L362nqiLhekCxCxDPaUMBQ==
+eslint-visitor-keys@^1.0.0, eslint-visitor-keys@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-1.1.0.tgz#e2a82cea84ff246ad6fb57f9bde5b46621459ec2"
+  integrity sha512-8y9YjtM1JBJU/A9Kc+SbaOV4y29sSWckBwMHa+FGtVj5gN/sbnKDf6xJUl+8g7FAij9LVaP8C24DUiH/f/2Z9A==
 
 eslint@^5.16.0:
   version "5.16.0"
@@ -8087,10 +8087,10 @@ react-scripts@3.0.1:
   optionalDependencies:
     fsevents "2.0.6"
 
-react-table@next:
-  version "7.0.0-alpha.7"
-  resolved "https://registry.yarnpkg.com/react-table/-/react-table-7.0.0-alpha.7.tgz#0cb6da6f32adb397e68505b7cdd4880d15d73017"
-  integrity sha512-oXE9RRkE2CFk1OloNCSTPQ9qxOdujgkCoW5b/srbJsBog/ySkWuozBTQkxH1wGNmnSxGyTrTxJqXdXPQam7VAw==
+react-table@latest:
+  version "7.0.0-rc.1"
+  resolved "https://registry.yarnpkg.com/react-table/-/react-table-7.0.0-rc.1.tgz#33f61b904d246d862a46a05ac4d8eda6343ea83b"
+  integrity sha512-tAuZg+TY64UUgBPRts/q+0JguGZpliYdoQZl7lAnLAQ/reU/5c04sCx54QcpH7n/PYVHMJEYkIU0ito8ZZ011w==
 
 react@^16.8.6:
   version "16.8.6"

examples/kitchen-sink-controlled/src/App.js

@@ -306,7 +306,7 @@ function Table({ columns, data, updateMyData, skipPageReset }) {
       updateMyData,
       // We also need to pass this so the page doesn't change
       // when we edit the data, undefined means using the default
-      getResetPageDeps: skipPageReset ? false : undefined,
+      autoResetPage: !skipPageReset,
     },
     useGroupBy,
     useFilters,

examples/kitchen-sink/src/App.js

@@ -303,9 +303,9 @@ function Table({ columns, data, updateMyData, skipReset }) {
       // cell renderer!
       updateMyData,
       // We also need to pass this so the page doesn't change
-      // when we edit the data. Undefined tells it to use the default
-      getResetPageDeps: skipReset ? false : undefined,
-      getResetSelectedRowPathsDeps: skipReset ? false : undefined,
+      // when we edit the data.
+      autoResetPage: !skipReset,
+      autoResetSelectedRows: !skipReset,
     },
     useFilters,
     useGroupBy,

examples/pagination-controlled/src/App.js

@@ -77,8 +77,6 @@ function Table({
     usePagination
   )
 
-  // Now we can get our table state from the hoisted table state tuple
-
   // Listen for changes in pagination and use the state to fetch our new data
   React.useEffect(() => {
     fetchData({ pageIndex, pageSize })
@@ -107,7 +105,16 @@ function Table({
           {headerGroups.map(headerGroup => (
             <tr {...headerGroup.getHeaderGroupProps()}>
               {headerGroup.headers.map(column => (
-                <th {...column.getHeaderProps()}>{column.render('Header')}</th>
+                <th {...column.getHeaderProps(column.getSortByToggleProps())}>
+                  {column.render('Header')}
+                  <span>
+                    {column.isSorted
+                      ? column.isSortedDesc
+                        ? ' 🔽'
+                        : ' 🔼'
+                      : ''}
+                  </span>
+                </th>
               ))}
             </tr>
           ))}

examples/pagination-controlled/yarn.lock

@@ -8087,10 +8087,10 @@ react-scripts@3.0.1:
   optionalDependencies:
     fsevents "2.0.6"
 
-react-table@next:
-  version "7.0.0-alpha.7"
-  resolved "https://registry.yarnpkg.com/react-table/-/react-table-7.0.0-alpha.7.tgz#0cb6da6f32adb397e68505b7cdd4880d15d73017"
-  integrity sha512-oXE9RRkE2CFk1OloNCSTPQ9qxOdujgkCoW5b/srbJsBog/ySkWuozBTQkxH1wGNmnSxGyTrTxJqXdXPQam7VAw==
+react-table@latest:
+  version "7.0.0-rc.1"
+  resolved "https://registry.yarnpkg.com/react-table/-/react-table-7.0.0-rc.1.tgz#33f61b904d246d862a46a05ac4d8eda6343ea83b"
+  integrity sha512-tAuZg+TY64UUgBPRts/q+0JguGZpliYdoQZl7lAnLAQ/reU/5c04sCx54QcpH7n/PYVHMJEYkIU0ito8ZZ011w==
 
 react@^16.8.6:
   version "16.8.6"

examples/pagination/src/App.js

@@ -62,7 +62,6 @@ function Table({ columns, data }) {
       columns,
       data,
       initialState: { pageIndex: 2 },
-      debug: true,
     },
     usePagination
   )

examples/pagination/yarn.lock

@@ -8087,10 +8087,10 @@ react-scripts@3.0.1:
   optionalDependencies:
     fsevents "2.0.6"
 
-react-table@next:
-  version "7.0.0-alpha.7"
-  resolved "https://registry.yarnpkg.com/react-table/-/react-table-7.0.0-alpha.7.tgz#0cb6da6f32adb397e68505b7cdd4880d15d73017"
-  integrity sha512-oXE9RRkE2CFk1OloNCSTPQ9qxOdujgkCoW5b/srbJsBog/ySkWuozBTQkxH1wGNmnSxGyTrTxJqXdXPQam7VAw==
+react-table@latest:
+  version "7.0.0-rc.1"
+  resolved "https://registry.yarnpkg.com/react-table/-/react-table-7.0.0-rc.1.tgz#33f61b904d246d862a46a05ac4d8eda6343ea83b"
+  integrity sha512-tAuZg+TY64UUgBPRts/q+0JguGZpliYdoQZl7lAnLAQ/reU/5c04sCx54QcpH7n/PYVHMJEYkIU0ito8ZZ011w==
 
 react@^16.8.6:
   version "16.8.6"

examples/row-selection/src/App.js

@@ -47,7 +47,6 @@ function Table({ columns, data }) {
     {
       columns,
       data,
-      debug: true,
     },
     useRowSelect
   )

examples/sorting/README.md

@@ -65,7 +65,7 @@ By default, the sorting will be `alphanumeric`. This can be changed in your `col
 Other options include `basic` and `datetime`.
 Note that if you're planning on sorting numbers between 0 and 1, `basic` sorting will be more accurate.
 
-More information can be found in the [API Docs](/docs/api.md#useSortBy)
+More information can be found in the [API Docs](/docs/api/README.md#useSortBy)
 
 ````diff
 const columns = React.useMemo(

package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-table",
-  "version": "7.0.0-beta.27",
-  "description": "A fast, lightweight, opinionated table and datagrid built on React",
+  "version": "7.0.0-rc.5",
+  "description": "Hooks for building lightweight, fast and extendable datagrids for React",
   "license": "MIT",
   "homepage": "https://github.com/tannerlinsley/react-table#readme",
   "repository": {

sizes-cjs.json

@@ -1,4 +1,84 @@
 [
+  {
+    "timestamp": 1575690248030,
+    "files": [
+      {
+        "filename": "index.js",
+        "size": 21026,
+        "delta": 1
+      }
+    ]
+  },
+  {
+    "timestamp": 1575675308812,
+    "files": [
+      {
+        "filename": "index.js",
+        "size": 21025,
+        "delta": -421
+      }
+    ]
+  },
+  {
+    "timestamp": 1575620433902,
+    "files": [
+      {
+        "filename": "index.js",
+        "size": 21446,
+        "delta": -1
+      }
+    ]
+  },
+  {
+    "timestamp": 1575607054721,
+    "files": [
+      {
+        "filename": "index.js",
+        "size": 21447,
+        "delta": 26
+      }
+    ]
+  },
+  {
+    "timestamp": 1575605755429,
+    "files": [
+      {
+        "filename": "index.js",
+        "size": 21421,
+        "delta": 170
+      }
+    ]
+  },
+  {
+    "timestamp": 1575579354616,
+    "files": [
+      {
+        "filename": "index.js",
+        "size": 21251,
+        "delta": 6
+      }
+    ]
+  },
+  {
+    "timestamp": 1575578830463,
+    "files": [
+      {
+        "filename": "index.js",
+        "size": 21245,
+        "delta": 652
+      }
+    ]
+  },
+  {
+    "timestamp": 1575555421868,
+    "files": [
+      {
+        "filename": "index.js",
+        "size": 20593,
+        "delta": 24
+      }
+    ]
+  },
   {
     "timestamp": 1575517726476,
     "files": [

sizes-es.json

@@ -1,4 +1,74 @@
 [
+  {
+    "timestamp": 1575675317538,
+    "files": [
+      {
+        "filename": "index.es.js",
+        "size": 20842,
+        "delta": -383
+      }
+    ]
+  },
+  {
+    "timestamp": 1575620442742,
+    "files": [
+      {
+        "filename": "index.es.js",
+        "size": 21225,
+        "delta": -1
+      }
+    ]
+  },
+  {
+    "timestamp": 1575607059725,
+    "files": [
+      {
+        "filename": "index.es.js",
+        "size": 21226,
+        "delta": 26
+      }
+    ]
+  },
+  {
+    "timestamp": 1575605764195,
+    "files": [
+      {
+        "filename": "index.es.js",
+        "size": 21200,
+        "delta": 170
+      }
+    ]
+  },
+  {
+    "timestamp": 1575579366180,
+    "files": [
+      {
+        "filename": "index.es.js",
+        "size": 21030,
+        "delta": 7
+      }
+    ]
+  },
+  {
+    "timestamp": 1575578837727,
+    "files": [
+      {
+        "filename": "index.es.js",
+        "size": 21023,
+        "delta": 575
+      }
+    ]
+  },
+  {
+    "timestamp": 1575555429414,
+    "files": [
+      {
+        "filename": "index.es.js",
+        "size": 20448,
+        "delta": 21
+      }
+    ]
+  },
   {
     "timestamp": 1575517715056,
     "files": [

src/hooks/useColumnVisibility.js

@@ -2,20 +2,33 @@ import React from 'react'
 
 import {
   actions,
-  reducerHandlers,
   functionalUpdate,
   mergeProps,
   applyPropHooks,
+  useGetLatest,
 } from '../utils'
 
-const pluginName = 'useColumnVisibility'
-
 actions.resetHiddenColumns = 'resetHiddenColumns'
 actions.toggleHideColumn = 'toggleHideColumn'
 actions.setHiddenColumns = 'setHiddenColumns'
 actions.toggleHideAllColumns = 'toggleHideAllColumns'
 
-reducerHandlers[pluginName] = (state, action) => {
+export const useColumnVisibility = hooks => {
+  hooks.getToggleHiddenProps = []
+  hooks.getToggleHideAllColumnsProps = []
+
+  hooks.stateReducers.push(reducer)
+  hooks.useInstanceBeforeDimensions.push(useInstanceBeforeDimensions)
+  hooks.columnsBeforeHeaderGroupsDeps.push((deps, instance) => [
+    ...deps,
+    instance.state.hiddenColumns,
+  ])
+  hooks.useInstance.push(useInstance)
+}
+
+useColumnVisibility.pluginName = 'useColumnVisibility'
+
+function reducer(state, action, previousState, instanceRef) {
   if (action.type === actions.init) {
     return {
       hiddenColumns: [],
@@ -62,25 +75,12 @@ reducerHandlers[pluginName] = (state, action) => {
     return {
       ...state,
       hiddenColumns: shouldAll
-        ? action.instanceRef.current.flatColumns.map(d => d.id)
+        ? instanceRef.current.flatColumns.map(d => d.id)
         : [],
     }
   }
 }
 
-export const useColumnVisibility = hooks => {
-  hooks.columnsBeforeHeaderGroupsDeps.push((deps, instance) => [
-    ...deps,
-    instance.state.hiddenColumns,
-  ])
-  hooks.useInstanceBeforeDimensions.push(useInstanceBeforeDimensions)
-  hooks.useInstance.push(useInstance)
-  hooks.getToggleHiddenProps = []
-  hooks.getToggleHideAllColumnsProps = []
-}
-
-useColumnVisibility.pluginName = pluginName
-
 function useInstanceBeforeDimensions(instance) {
   const {
     headers,
@@ -123,8 +123,7 @@ function useInstance(instance) {
     state: { hiddenColumns },
   } = instance
 
-  const instanceRef = React.useRef()
-  instanceRef.current = instance
+  const getInstance = useGetLatest(instance)
 
   const allColumnsHidden = flatColumns.length === hiddenColumns.length
 
@@ -149,10 +148,7 @@ function useInstance(instance) {
           checked: column.isVisible,
           title: 'Toggle Column Visible',
         },
-        applyPropHooks(
-          instanceRef.current.hooks.getToggleHiddenProps,
-          instanceRef.current
-        ),
+        applyPropHooks(getInstance().hooks.getToggleHiddenProps, getInstance()),
         props
       )
     }
@@ -188,8 +184,8 @@ function useInstance(instance) {
         indeterminate: !allColumnsHidden && hiddenColumns.length,
       },
       applyPropHooks(
-        instanceRef.current.hooks.getToggleHideAllColumnsProps,
-        instanceRef.current
+        getInstance().hooks.getToggleHideAllColumnsProps,
+        getInstance()
       ),
       props
     )

src/hooks/useTable.js

@@ -3,7 +3,6 @@ import React from 'react'
 //
 import {
   actions,
-  reducerHandlers,
   applyHooks,
   applyPropHooks,
   mergeProps,
@@ -11,12 +10,13 @@ import {
   decorateColumnTree,
   makeHeaderGroups,
   flattenBy,
+  useGetLatest,
+  useConsumeHookGetter,
 } from '../utils'
 
 import { useColumnVisibility } from './useColumnVisibility'
 
-const renderErr =
-  'You must specify a valid render component. This could be "column.Cell", "column.Header", "column.Filter", "column.Aggregated" or any other custom renderer component.'
+let renderErr = 'Renderer Error'
 
 const defaultInitialState = {}
 const defaultColumnInstance = {}
@@ -34,60 +34,21 @@ export const useTable = (props, ...plugins) => {
     defaultColumn = defaultColumnInstance,
     getSubRows = defaultGetSubRows,
     getRowId = defaultGetRowId,
-    reducer: userReducer = defaultReducer,
+    stateReducer: userStateReducer = defaultReducer,
     useControlledState = defaultUseControlledState,
-    debug,
   } = props
 
   plugins = [useColumnVisibility, ...plugins]
 
-  debug = process.env.NODE_ENV === 'production' ? false : debug
-
-  const reducer = (state, action) => {
-    let nextState = Object.keys(reducerHandlers)
-      .map(key => reducerHandlers[key])
-      .reduce((state, handler) => handler(state, action) || state, state)
-
-    nextState = userReducer(nextState, action, state)
-
-    if (process.env.NODE_ENV !== 'production' && debug) {
-      console.info('')
-      console.info('React Table Action: ', action)
-      console.info('New State: ', nextState)
-    }
-    return nextState
-  }
-
-  // But use the users table state if provided
-  const [reducerState, originalDispatch] = React.useReducer(
-    reducer,
-    undefined,
-    () => reducer(initialState, { type: actions.init })
-  )
-
-  const state = useControlledState(reducerState)
-
-  // The table instance ref
+  // The table instance
   let instanceRef = React.useRef({})
 
-  const dispatch = React.useCallback(action => {
-    if (!action.type) {
-      if (process.env.NODE_ENV !== 'production') {
-        console.info({ action })
-        throw new Error('Unknown Action Type! 👆')
-      }
-      throw new Error()
-    }
-    originalDispatch({ ...action, instanceRef })
-  }, [])
-
   Object.assign(instanceRef.current, {
     ...props,
-    data, // The raw data
-    state, // The state dispatcher
-    dispatch, // The resolved table state
-    plugins, // All resolved plugins
+    plugins,
+    data,
     hooks: {
+      stateReducers: [],
       columnsBeforeHeaderGroups: [],
       columnsBeforeHeaderGroupsDeps: [],
       useInstanceBeforeDimensions: [],
@@ -98,19 +59,63 @@ export const useTable = (props, ...plugins) => {
       getTableBodyProps: [],
       getRowProps: [],
       getHeaderGroupProps: [],
+      getFooterGroupProps: [],
       getHeaderProps: [],
+      getFooterProps: [],
       getCellProps: [],
     },
   })
 
-  // Allow plugins to register hooks
-  if (process.env.NODE_ENV !== 'production' && debug) console.time('plugins')
-
+  // Allow plugins to register hooks as early as possible
   plugins.filter(Boolean).forEach(plugin => {
     plugin(instanceRef.current.hooks)
   })
 
-  if (process.env.NODE_ENV !== 'production' && debug) console.timeEnd('plugins')
+  // Snapshot hook and disallow more from being added
+  const getStateReducers = useConsumeHookGetter(
+    instanceRef.current.hooks,
+    'stateReducers'
+  )
+
+  // Setup user reducer ref
+  const getUserStateReducer = useGetLatest(userStateReducer)
+
+  // Build the reducer
+  const reducer = React.useCallback(
+    (state, action) => {
+      // Detect invalid actions
+      if (!action.type) {
+        console.info({ action })
+        throw new Error('Unknown Action 👆')
+      }
+
+      // Reduce the state from all plugin reducers
+      return [
+        ...getStateReducers(),
+        // Allow the user to add their own state reducer(s)
+        ...(Array.isArray(getUserStateReducer())
+          ? getUserStateReducer()
+          : [getUserStateReducer()]),
+      ].reduce(
+        (s, handler) => handler(s, action, state, instanceRef) || s,
+        state
+      )
+    },
+    [getStateReducers, getUserStateReducer]
+  )
+
+  // Start the reducer
+  const [reducerState, dispatch] = React.useReducer(reducer, undefined, () =>
+    reducer(initialState, { type: actions.init })
+  )
+
+  // Allow the user to control the final state with hooks
+  const state = useControlledState(reducerState)
+
+  Object.assign(instanceRef.current, {
+    state, // The state dispatcher
+    dispatch, // The resolved table state
+  })
 
   // Decorate All the columns
   let columns = React.useMemo(
@@ -118,30 +123,33 @@ export const useTable = (props, ...plugins) => {
     [defaultColumn, userColumns]
   )
 
+  // Snapshot hook and disallow more from being added
+  const getColumnsBeforeHeaderGroups = useConsumeHookGetter(
+    instanceRef.current.hooks,
+    'columnsBeforeHeaderGroups'
+  )
+
+  // Snapshot hook and disallow more from being added
+  const getColumnsBeforeHeaderGroupsDeps = useConsumeHookGetter(
+    instanceRef.current.hooks,
+    'columnsBeforeHeaderGroupsDeps'
+  )
+
   // Get the flat list of all columns and allow hooks to decorate
   // those columns (and trigger this memoization via deps)
   let flatColumns = React.useMemo(() => {
-    if (process.env.NODE_ENV !== 'production' && debug)
-      console.time('hooks.columnsBeforeHeaderGroups')
-
     let newColumns = applyHooks(
-      instanceRef.current.hooks.columnsBeforeHeaderGroups,
+      getColumnsBeforeHeaderGroups(),
       flattenBy(columns, 'columns'),
       instanceRef.current
     )
 
-    if (process.env.NODE_ENV !== 'production' && debug)
-      console.timeEnd('hooks.columnsBeforeHeaderGroups')
     return newColumns
   }, [
     columns,
-    debug,
+    getColumnsBeforeHeaderGroups,
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    ...applyHooks(
-      instanceRef.current.hooks.columnsBeforeHeaderGroupsDeps,
-      [],
-      instanceRef.current
-    ),
+    ...getColumnsBeforeHeaderGroupsDeps(),
   ])
 
   // Make the headerGroups
@@ -164,9 +172,6 @@ export const useTable = (props, ...plugins) => {
 
   // Access the row model
   const [rows, flatRows] = React.useMemo(() => {
-    if (process.env.NODE_ENV !== 'production' && debug)
-      console.time('getAccessedRows')
-
     let flatRows = []
 
     // Access the row's data
@@ -221,10 +226,9 @@ export const useTable = (props, ...plugins) => {
 
     // Use the resolved data
     const accessedData = data.map((d, i) => accessRow(d, i))
-    if (process.env.NODE_ENV !== 'production' && debug)
-      console.timeEnd('getAccessedRows')
+
     return [accessedData, flatRows]
-  }, [debug, data, getRowId, getSubRows, flatColumns])
+  }, [data, getRowId, getSubRows, flatColumns])
 
   instanceRef.current.rows = rows
   instanceRef.current.flatRows = flatRows
@@ -235,26 +239,39 @@ export const useTable = (props, ...plugins) => {
     []
   )
 
-  if (process.env.NODE_ENV !== 'production' && debug)
-    console.time('hooks.useInstanceBeforeDimensions')
+  // Snapshot hook and disallow more from being added
+  const getUseInstanceBeforeDimensions = useConsumeHookGetter(
+    instanceRef.current.hooks,
+    'useInstanceBeforeDimensions'
+  )
+
   instanceRef.current = applyHooks(
-    instanceRef.current.hooks.useInstanceBeforeDimensions,
+    getUseInstanceBeforeDimensions(),
     instanceRef.current
   )
-  if (process.env.NODE_ENV !== 'production' && debug)
-    console.timeEnd('hooks.useInstanceBeforeDimensions')
 
   // Header Visibility is needed by this point
   calculateDimensions(instanceRef.current)
 
-  if (process.env.NODE_ENV !== 'production' && debug)
-    console.time('hooks.useInstance')
-  instanceRef.current = applyHooks(
-    instanceRef.current.hooks.useInstance,
-    instanceRef.current
+  // Snapshot hook and disallow more from being added
+  const getUseInstance = useConsumeHookGetter(
+    instanceRef.current.hooks,
+    'useInstance'
+  )
+
+  instanceRef.current = applyHooks(getUseInstance(), instanceRef.current)
+
+  // Snapshot hook and disallow more from being added
+  const getHeaderPropsHooks = useConsumeHookGetter(
+    instanceRef.current.hooks,
+    'getHeaderProps'
+  )
+
+  // Snapshot hook and disallow more from being added
+  const getFooterPropsHooks = useConsumeHookGetter(
+    instanceRef.current.hooks,
+    'getFooterProps'
   )
-  if (process.env.NODE_ENV !== 'production' && debug)
-    console.timeEnd('hooks.useInstance')
 
   // Each materialized header needs to be assigned a render function and other
   // prop getter properties here.
@@ -281,30 +298,49 @@ export const useTable = (props, ...plugins) => {
           key: ['header', column.id].join('_'),
           colSpan: column.totalVisibleHeaderCount,
         },
-        applyPropHooks(
-          instanceRef.current.hooks.getHeaderProps,
-          column,
-          instanceRef.current
-        ),
+        applyPropHooks(getHeaderPropsHooks(), column, instanceRef.current),
+        props
+      )
+
+    // Give columns/headers a default getFooterProps
+    column.getFooterProps = props =>
+      mergeProps(
+        {
+          key: ['footer', column.id].join('_'),
+          colSpan: column.totalVisibleHeaderCount,
+        },
+        applyPropHooks(getFooterPropsHooks(), column, instanceRef.current),
         props
       )
   })
 
+  // Snapshot hook and disallow more from being added
+  const getHeaderGroupPropsHooks = useConsumeHookGetter(
+    instanceRef.current.hooks,
+    'getHeaderGroupProps'
+  )
+
+  // Snapshot hook and disallow more from being added
+  const getFooterGroupsPropsHooks = useConsumeHookGetter(
+    instanceRef.current.hooks,
+    'getFooterGroupProps'
+  )
+
   instanceRef.current.headerGroups = instanceRef.current.headerGroups.filter(
     (headerGroup, i) => {
       // Filter out any headers and headerGroups that don't have visible columns
-      headerGroup.headers = headerGroup.headers.filter(header => {
+      headerGroup.headers = headerGroup.headers.filter(column => {
         const recurse = headers =>
-          headers.filter(header => {
-            if (header.headers) {
-              return recurse(header.headers)
+          headers.filter(column => {
+            if (column.headers) {
+              return recurse(column.headers)
             }
-            return header.isVisible
+            return column.isVisible
           }).length
-        if (header.headers) {
-          return recurse(header.headers)
+        if (column.headers) {
+          return recurse(column.headers)
         }
-        return header.isVisible
+        return column.isVisible
       })
 
       // Give headerGroups getRowProps
@@ -315,7 +351,20 @@ export const useTable = (props, ...plugins) => {
               key: [`header${i}`].join('_'),
             },
             applyPropHooks(
-              instanceRef.current.hooks.getHeaderGroupProps,
+              getHeaderGroupPropsHooks(),
+              headerGroup,
+              instanceRef.current
+            ),
+            props
+          )
+
+        headerGroup.getFooterGroupProps = (props = {}) =>
+          mergeProps(
+            {
+              key: [`footer${i}`].join('_'),
+            },
+            applyPropHooks(
+              getFooterGroupsPropsHooks(),
               headerGroup,
               instanceRef.current
             ),
@@ -329,97 +378,123 @@ export const useTable = (props, ...plugins) => {
     }
   )
 
+  instanceRef.current.footerGroups = [
+    ...instanceRef.current.headerGroups,
+  ].reverse()
+
   // Run the rows (this could be a dangerous hook with a ton of data)
-  if (process.env.NODE_ENV !== 'production' && debug)
-    console.time('hooks.useRows')
+
+  // Snapshot hook and disallow more from being added
+  const getUseRowsHooks = useConsumeHookGetter(
+    instanceRef.current.hooks,
+    'useRows'
+  )
+
   instanceRef.current.rows = applyHooks(
-    instanceRef.current.hooks.useRows,
+    getUseRowsHooks(),
     instanceRef.current.rows,
     instanceRef.current
   )
-  if (process.env.NODE_ENV !== 'production' && debug)
-    console.timeEnd('hooks.useRows')
 
   // The prepareRow function is absolutely necessary and MUST be called on
   // any rows the user wishes to be displayed.
 
-  instanceRef.current.prepareRow = React.useCallback(row => {
-    row.getRowProps = props =>
-      mergeProps(
-        { key: ['row', ...row.path].join('_') },
-        applyPropHooks(
-          instanceRef.current.hooks.getRowProps,
-          row,
-          instanceRef.current
-        ),
-        props
-      )
+  // Snapshot hook and disallow more from being added
+  const getPrepareRowHooks = useConsumeHookGetter(
+    instanceRef.current.hooks,
+    'prepareRow'
+  )
 
-    // Build the visible cells for each row
-    row.cells = instanceRef.current.flatColumns
-      .filter(d => d.isVisible)
-      .map(column => {
-        const cell = {
-          column,
-          row,
-          value: row.values[column.id],
-        }
+  // Snapshot hook and disallow more from being added
+  const getRowPropsHooks = useConsumeHookGetter(
+    instanceRef.current.hooks,
+    'getRowProps'
+  )
 
-        // Give each cell a getCellProps base
-        cell.getCellProps = props => {
-          const columnPathStr = [...row.path, column.id].join('_')
-          return mergeProps(
-            {
-              key: ['cell', columnPathStr].join('_'),
-            },
-            applyPropHooks(
-              instanceRef.current.hooks.getCellProps,
-              cell,
-              instanceRef.current
-            ),
-            props
-          )
-        }
+  // Snapshot hook and disallow more from being added
+  const getCellPropsHooks = useConsumeHookGetter(
+    instanceRef.current.hooks,
+    'getCellProps'
+  )
 
-        // Give each cell a renderer function (supports multiple renderers)
-        cell.render = (type, userProps = {}) => {
-          const Comp = typeof type === 'string' ? column[type] : type
+  instanceRef.current.prepareRow = React.useCallback(
+    row => {
+      row.getRowProps = props =>
+        mergeProps(
+          { key: ['row', ...row.path].join('_') },
+          applyPropHooks(getRowPropsHooks(), row, instanceRef.current),
+          props
+        )
 
-          if (typeof Comp === 'undefined') {
-            throw new Error(renderErr)
-          }
-
-          return flexRender(Comp, {
-            ...instanceRef.current,
+      // Build the visible cells for each row
+      row.cells = instanceRef.current.flatColumns
+        .filter(d => d.isVisible)
+        .map(column => {
+          const cell = {
             column,
             row,
-            cell,
-            ...userProps,
-          })
-        }
+            value: row.values[column.id],
+          }
 
-        return cell
-      })
+          // Give each cell a getCellProps base
+          cell.getCellProps = props => {
+            const columnPathStr = [...row.path, column.id].join('_')
+            return mergeProps(
+              {
+                key: ['cell', columnPathStr].join('_'),
+              },
+              applyPropHooks(getCellPropsHooks(), cell, instanceRef.current),
+              props
+            )
+          }
 
-    // need to apply any row specific hooks (useExpanded requires this)
-    applyHooks(instanceRef.current.hooks.prepareRow, row, instanceRef.current)
-  }, [])
+          // Give each cell a renderer function (supports multiple renderers)
+          cell.render = (type, userProps = {}) => {
+            const Comp = typeof type === 'string' ? column[type] : type
+
+            if (typeof Comp === 'undefined') {
+              throw new Error(renderErr)
+            }
+
+            return flexRender(Comp, {
+              ...instanceRef.current,
+              column,
+              row,
+              cell,
+              ...userProps,
+            })
+          }
+
+          return cell
+        })
+
+      // need to apply any row specific hooks (useExpanded requires this)
+      applyHooks(getPrepareRowHooks(), row, instanceRef.current)
+    },
+    [getCellPropsHooks, getPrepareRowHooks, getRowPropsHooks]
+  )
+
+  // Snapshot hook and disallow more from being added
+  const getTablePropsHooks = useConsumeHookGetter(
+    instanceRef.current.hooks,
+    'getTableProps'
+  )
 
   instanceRef.current.getTableProps = userProps =>
     mergeProps(
-      applyPropHooks(
-        instanceRef.current.hooks.getTableProps,
-        instanceRef.current
-      ),
+      applyPropHooks(getTablePropsHooks(), instanceRef.current),
       userProps
     )
 
+  // Snapshot hook and disallow more from being added
+  const getTableBodyPropsHooks = useConsumeHookGetter(
+    instanceRef.current.hooks,
+    'getTableBodyProps'
+  )
+
   instanceRef.current.getTableBodyProps = userProps =>
     mergeProps(
-      applyPropHooks(
-        instanceRef.current.hooks.getTableBodyProps,
-        instanceRef.current
-      ),
+      applyPropHooks(getTableBodyPropsHooks(), instanceRef.current),
       userProps
     )
 

src/index.js

@@ -1,4 +1,4 @@
-export * from './utils'
+export * from './publicUtils'
 export { useTable } from './hooks/useTable'
 export { useExpanded } from './plugin-hooks/useExpanded'
 export { useFilters } from './plugin-hooks/useFilters'

src/plugin-hooks/tests/__snapshots__/useSortBy.test.js.snap

@@ -5,7 +5,7 @@ Snapshot Diff:
 - First value
 + Second value
 
-@@ -22,11 +22,13 @@
+@@ -20,11 +20,13 @@
             colspan="1"
             style="cursor: pointer;"
             title="Toggle SortBy"
@@ -20,7 +20,7 @@ Snapshot Diff:
             colspan="1"
             style="cursor: pointer;"
             title="Toggle SortBy"
-@@ -69,66 +71,66 @@
+@@ -67,66 +69,66 @@
         </tr>
       </thead>
       <tbody>
@@ -112,7 +112,7 @@ Snapshot Diff:
 - First value
 + Second value
 
-@@ -23,11 +23,11 @@
+@@ -21,11 +21,11 @@
             style="cursor: pointer;"
             title="Toggle SortBy"
           >
@@ -125,7 +125,7 @@ Snapshot Diff:
           <th
             colspan="1"
             style="cursor: pointer;"
-@@ -71,26 +71,26 @@
+@@ -69,26 +69,26 @@
         </tr>
       </thead>
       <tbody>
@@ -158,7 +158,7 @@ Snapshot Diff:
         <tr>
           <td>
             firstName: joe
-@@ -111,26 +111,26 @@
+@@ -109,26 +109,26 @@
             progress: 10
           </td>
         </tr>

src/plugin-hooks/useColumnOrder.js

@@ -1,15 +1,23 @@
 import React from 'react'
 
-import { reducerHandlers, functionalUpdate, actions } from '../utils'
-
-const pluginName = 'useColumnOrder'
+import { functionalUpdate, actions } from '../utils'
 
 // Actions
 actions.resetColumnOrder = 'resetColumnOrder'
 actions.setColumnOrder = 'setColumnOrder'
 
-// Reducer
-reducerHandlers[pluginName] = (state, action) => {
+export const useColumnOrder = hooks => {
+  hooks.stateReducers.push(reducer)
+  hooks.columnsBeforeHeaderGroupsDeps.push((deps, instance) => {
+    return [...deps, instance.state.columnOrder]
+  })
+  hooks.columnsBeforeHeaderGroups.push(columnsBeforeHeaderGroups)
+  hooks.useInstance.push(useInstance)
+}
+
+useColumnOrder.pluginName = 'useColumnOrder'
+
+function reducer(state, action) {
   if (action.type === actions.init) {
     return {
       columnOrder: [],
@@ -32,16 +40,6 @@ reducerHandlers[pluginName] = (state, action) => {
   }
 }
 
-export const useColumnOrder = hooks => {
-  hooks.columnsBeforeHeaderGroupsDeps.push((deps, instance) => {
-    return [...deps, instance.state.columnOrder]
-  })
-  hooks.columnsBeforeHeaderGroups.push(columnsBeforeHeaderGroups)
-  hooks.useInstance.push(useInstance)
-}
-
-useColumnOrder.pluginName = pluginName
-
 function columnsBeforeHeaderGroups(columns, instance) {
   const {
     state: { columnOrder },

src/plugin-hooks/useExpanded.js

@@ -2,21 +2,28 @@ import React from 'react'
 
 import {
   actions,
-  reducerHandlers,
   mergeProps,
   applyPropHooks,
   expandRows,
-  safeUseLayoutEffect,
+  useMountedLayoutEffect,
+  useGetLatest,
 } from '../utils'
 
-const pluginName = 'useExpanded'
-
 // Actions
 actions.toggleExpandedByPath = 'toggleExpandedByPath'
 actions.resetExpanded = 'resetExpanded'
 
+export const useExpanded = hooks => {
+  hooks.getExpandedToggleProps = []
+
+  hooks.stateReducers.push(reducer)
+  hooks.useInstance.push(useInstance)
+}
+
+useExpanded.pluginName = 'useExpanded'
+
 // Reducer
-reducerHandlers[pluginName] = (state, action) => {
+function reducer(state, action) {
   if (action.type === actions.init) {
     return {
       expanded: [],
@@ -35,7 +42,7 @@ reducerHandlers[pluginName] = (state, action) => {
     const { path, expanded } = action
     const key = path.join('.')
     const exists = state.expanded.includes(key)
-    const shouldExist = typeof set !== 'undefined' ? expanded : !exists
+    const shouldExist = typeof expanded !== 'undefined' ? expanded : !exists
     let newExpanded = new Set(state.expanded)
 
     if (!exists && shouldExist) {
@@ -53,39 +60,27 @@ reducerHandlers[pluginName] = (state, action) => {
   }
 }
 
-export const useExpanded = hooks => {
-  hooks.getExpandedToggleProps = []
-  hooks.useInstance.push(useInstance)
-}
-
-useExpanded.pluginName = pluginName
-
-const defaultGetResetExpandedDeps = ({ data }) => [data]
-
 function useInstance(instance) {
   const {
-    debug,
+    data,
     rows,
     manualExpandedKey = 'expanded',
     paginateExpandedRows = true,
     expandSubRows = true,
     hooks,
+    autoResetExpanded = true,
     state: { expanded },
     dispatch,
-    getResetExpandedDeps = defaultGetResetExpandedDeps,
   } = instance
 
+  const getAutoResetExpanded = useGetLatest(autoResetExpanded)
+
   // Bypass any effects from firing when this changes
-  const isMountedRef = React.useRef()
-  safeUseLayoutEffect(() => {
-    if (isMountedRef.current) {
+  useMountedLayoutEffect(() => {
+    if (getAutoResetExpanded()) {
       dispatch({ type: actions.resetExpanded })
     }
-    isMountedRef.current = true
-  }, [
-    dispatch,
-    ...(getResetExpandedDeps ? getResetExpandedDeps(instance) : []),
-  ])
+  }, [dispatch, data])
 
   const toggleExpandedByPath = (path, expanded) => {
     dispatch({ type: actions.toggleExpandedByPath, path, expanded })
@@ -121,22 +116,12 @@ function useInstance(instance) {
   })
 
   const expandedRows = React.useMemo(() => {
-    if (process.env.NODE_ENV !== 'production' && debug)
-      console.info('getExpandedRows')
-
     if (paginateExpandedRows) {
       return expandRows(rows, { manualExpandedKey, expanded, expandSubRows })
     }
 
     return rows
-  }, [
-    debug,
-    paginateExpandedRows,
-    rows,
-    manualExpandedKey,
-    expanded,
-    expandSubRows,
-  ])
+  }, [paginateExpandedRows, rows, manualExpandedKey, expanded, expandSubRows])
 
   const expandedDepth = findExpandedDepth(expanded)
 

src/plugin-hooks/useFilters.js

@@ -2,23 +2,27 @@ import React from 'react'
 
 import {
   actions,
-  reducerHandlers,
   getFirstDefined,
   isFunction,
-  safeUseLayoutEffect,
+  useMountedLayoutEffect,
   functionalUpdate,
+  useGetLatest,
 } from '../utils'
 import * as filterTypes from '../filterTypes'
 
-const pluginName = 'useFilters'
-
 // Actions
 actions.resetFilters = 'resetFilters'
 actions.setFilter = 'setFilter'
 actions.setAllFilters = 'setAllFilters'
 
-// Reducer
-reducerHandlers[pluginName] = (state, action) => {
+export const useFilters = hooks => {
+  hooks.stateReducers.push(reducer)
+  hooks.useInstance.push(useInstance)
+}
+
+useFilters.pluginName = 'useFilters'
+
+function reducer(state, action, previousState, instanceRef) {
   if (action.type === actions.init) {
     return {
       filters: {},
@@ -34,14 +38,8 @@ reducerHandlers[pluginName] = (state, action) => {
   }
 
   if (action.type === actions.setFilter) {
-    const {
-      columnId,
-      filterValue,
-      instanceRef: {
-        current: { flatColumns, userFilterTypes },
-      },
-    } = action
-
+    const { columnId, filterValue } = action
+    const { flatColumns, userFilterTypes } = instanceRef.current
     const column = flatColumns.find(d => d.id === columnId)
 
     if (!column) {
@@ -78,13 +76,8 @@ reducerHandlers[pluginName] = (state, action) => {
   }
 
   if (action.type === actions.setAllFilters) {
-    const {
-      filters,
-      instanceRef: {
-        current: { flatColumns, filterTypes: userFilterTypes },
-      },
-    } = action
-
+    const { filters } = action
+    const { flatColumns, filterTypes: userFilterTypes } = instanceRef.current
     const newFilters = functionalUpdate(filters, state.filters)
 
     // Filter out undefined values
@@ -109,15 +102,9 @@ reducerHandlers[pluginName] = (state, action) => {
   }
 }
 
-export const useFilters = hooks => {
-  hooks.useInstance.push(useInstance)
-}
-
-useFilters.pluginName = pluginName
-
 function useInstance(instance) {
   const {
-    debug,
+    data,
     rows,
     flatRows,
     flatColumns,
@@ -127,21 +114,12 @@ function useInstance(instance) {
     disableFilters,
     state: { filters },
     dispatch,
-    getResetFiltersDeps = false,
+    autoResetFilters = true,
   } = instance
 
   const preFilteredRows = rows
   const preFilteredFlatRows = flatRows
 
-  // Bypass any effects from firing when this changes
-  const isMountedRef = React.useRef()
-  safeUseLayoutEffect(() => {
-    if (isMountedRef.current) {
-      dispatch({ type: actions.resetFilters })
-    }
-    isMountedRef.current = true
-  }, [dispatch, ...(getResetFiltersDeps ? getResetFiltersDeps(instance) : [])])
-
   const setFilter = (columnId, filterValue) => {
     dispatch({ type: actions.setFilter, columnId, filterValue })
   }
@@ -193,9 +171,6 @@ function useInstance(instance) {
 
     const filteredFlatRows = []
 
-    if (process.env.NODE_ENV !== 'production' && debug)
-      console.info('getFilteredRows')
-
     // Filters top level and nested rows
     const filterRows = (rows, depth = 0) => {
       let filteredRows = rows
@@ -265,15 +240,7 @@ function useInstance(instance) {
       filteredRows: filterRows(rows),
       filteredFlatRows,
     }
-  }, [
-    manualFilters,
-    filters,
-    debug,
-    rows,
-    flatRows,
-    flatColumns,
-    userFilterTypes,
-  ])
+  }, [manualFilters, filters, rows, flatRows, flatColumns, userFilterTypes])
 
   React.useMemo(() => {
     // Now that each filtered column has it's partially filtered rows,
@@ -290,6 +257,14 @@ function useInstance(instance) {
     })
   }, [filteredRows, filters, flatColumns])
 
+  const getAutoResetFilters = useGetLatest(autoResetFilters)
+
+  useMountedLayoutEffect(() => {
+    if (getAutoResetFilters()) {
+      dispatch({ type: actions.resetFilters })
+    }
+  }, [dispatch, manualFilters ? null : data])
+
   return {
     ...instance,
     setFilter,

src/plugin-hooks/useGroupBy.js

@@ -3,22 +3,33 @@ import React from 'react'
 import * as aggregations from '../aggregations'
 import {
   actions,
-  reducerHandlers,
   mergeProps,
   applyPropHooks,
   defaultGroupByFn,
   getFirstDefined,
   ensurePluginOrder,
+  useMountedLayoutEffect,
+  useGetLatest,
 } from '../utils'
 
-const pluginName = 'useGroupBy'
-
 // Actions
 actions.resetGroupBy = 'resetGroupBy'
 actions.toggleGroupBy = 'toggleGroupBy'
 
+export const useGroupBy = hooks => {
+  hooks.stateReducers.push(reducer)
+  hooks.columnsBeforeHeaderGroupsDeps.push((deps, instance) => [
+    ...deps,
+    instance.state.groupBy,
+  ])
+  hooks.columnsBeforeHeaderGroups.push(columnsBeforeHeaderGroups)
+  hooks.useInstance.push(useInstance)
+}
+
+useGroupBy.pluginName = 'useGroupBy'
+
 // Reducer
-reducerHandlers[pluginName] = (state, action) => {
+function reducer(state, action) {
   if (action.type === actions.init) {
     return {
       groupBy: [],
@@ -53,17 +64,6 @@ reducerHandlers[pluginName] = (state, action) => {
   }
 }
 
-export const useGroupBy = hooks => {
-  hooks.columnsBeforeHeaderGroups.push(columnsBeforeHeaderGroups)
-  hooks.columnsBeforeHeaderGroupsDeps.push((deps, instance) => {
-    deps.push(instance.state.groupBy)
-    return deps
-  })
-  hooks.useInstance.push(useInstance)
-}
-
-useGroupBy.pluginName = pluginName
-
 function columnsBeforeHeaderGroups(flatColumns, { state: { groupBy } }) {
   // Sort grouped columns to the start of the column list
   // before the headers are built
@@ -86,7 +86,7 @@ const defaultUserAggregations = {}
 
 function useInstance(instance) {
   const {
-    debug,
+    data,
     rows,
     flatRows,
     flatColumns,
@@ -100,6 +100,8 @@ function useInstance(instance) {
     plugins,
     state: { groupBy },
     dispatch,
+    autoResetGroupBy = true,
+    manaulGroupBy,
   } = instance
 
   ensurePluginOrder(plugins, [], 'useGroupBy', ['useSortBy', 'useExpanded'])
@@ -183,10 +185,7 @@ function useInstance(instance) {
       return [rows, flatRows]
     }
 
-    if (process.env.NODE_ENV !== 'production' && 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, isAggregated) => {
       const values = {}
@@ -289,7 +288,6 @@ function useInstance(instance) {
   }, [
     manualGroupBy,
     groupBy,
-    debug,
     rows,
     flatRows,
     flatColumns,
@@ -297,6 +295,14 @@ function useInstance(instance) {
     groupByFn,
   ])
 
+  const getAutoResetGroupBy = useGetLatest(autoResetGroupBy)
+
+  useMountedLayoutEffect(() => {
+    if (getAutoResetGroupBy()) {
+      dispatch({ type: actions.resetGroupBy })
+    }
+  }, [dispatch, manaulGroupBy ? null : data])
+
   return {
     ...instance,
     toggleGroupBy,

src/plugin-hooks/usePagination.js

@@ -4,11 +4,11 @@ import React from 'react'
 
 import {
   actions,
-  reducerHandlers,
   ensurePluginOrder,
-  safeUseLayoutEffect,
   expandRows,
   functionalUpdate,
+  useMountedLayoutEffect,
+  useGetLatest,
 } from '../utils'
 
 const pluginName = 'usePagination'
@@ -18,8 +18,14 @@ actions.resetPage = 'resetPage'
 actions.gotoPage = 'gotoPage'
 actions.setPageSize = 'setPageSize'
 
-// Reducer
-reducerHandlers[pluginName] = (state, action) => {
+export const usePagination = hooks => {
+  hooks.stateReducers.push(reducer)
+  hooks.useInstance.push(useInstance)
+}
+
+usePagination.pluginName = pluginName
+
+function reducer(state, action, previousState, instanceRef) {
   if (action.type === actions.init) {
     return {
       pageSize: 10,
@@ -36,7 +42,7 @@ reducerHandlers[pluginName] = (state, action) => {
   }
 
   if (action.type === actions.gotoPage) {
-    const { pageCount } = action.instanceRef.current
+    const { pageCount } = instanceRef.current
     const newPageIndex = functionalUpdate(action.pageIndex, state.pageIndex)
 
     if (newPageIndex < 0 || newPageIndex > pageCount - 1) {
@@ -61,31 +67,22 @@ reducerHandlers[pluginName] = (state, action) => {
   }
 }
 
-export const usePagination = hooks => {
-  hooks.useInstance.push(useInstance)
-}
-
-usePagination.pluginName = pluginName
-
-const defaultGetResetPageDeps = ({
-  data,
-  manualPagination,
-  state: { filters, groupBy, sortBy },
-}) => [manualPagination ? null : data, filters, groupBy, sortBy]
-
 function useInstance(instance) {
   const {
     rows,
-    manualPagination,
-    getResetPageDeps = defaultGetResetPageDeps,
+    autoResetPage = true,
     manualExpandedKey = 'expanded',
-    debug,
     plugins,
     pageCount: userPageCount,
     paginateExpandedRows = true,
     expandSubRows = true,
-    state: { pageSize, pageIndex, expanded },
+    state: { pageSize, pageIndex, expanded, filters, groupBy, sortBy },
     dispatch,
+    data,
+    manualPagination,
+    manualFilters,
+    manualGroupBy,
+    manualSortBy,
   } = instance
 
   ensurePluginOrder(
@@ -95,14 +92,19 @@ function useInstance(instance) {
     []
   )
 
-  // Bypass any effects from firing when this changes
-  const isMountedRef = React.useRef()
-  safeUseLayoutEffect(() => {
-    if (isMountedRef.current) {
+  const getAutoResetPage = useGetLatest(autoResetPage)
+
+  useMountedLayoutEffect(() => {
+    if (getAutoResetPage()) {
       dispatch({ type: actions.resetPage })
     }
-    isMountedRef.current = true
-  }, [dispatch, ...(getResetPageDeps ? getResetPageDeps(instance) : [])])
+  }, [
+    dispatch,
+    manualPagination ? null : data,
+    manualPagination || manualFilters ? null : filters,
+    manualPagination || manualGroupBy ? null : groupBy,
+    manualPagination || manualSortBy ? null : sortBy,
+  ])
 
   const pageCount = manualPagination
     ? userPageCount
@@ -119,9 +121,6 @@ function useInstance(instance) {
     if (manualPagination) {
       page = rows
     } else {
-      if (process.env.NODE_ENV !== 'production' && debug)
-        console.info('getPage')
-
       const pageStart = pageSize * pageIndex
       const pageEnd = pageStart + pageSize
 
@@ -134,7 +133,6 @@ function useInstance(instance) {
 
     return expandRows(page, { manualExpandedKey, expanded, expandSubRows })
   }, [
-    debug,
     expandSubRows,
     expanded,
     manualExpandedKey,

src/plugin-hooks/useResizeColumns.js

@@ -1,16 +1,12 @@
-import React from 'react'
-
 import {
   actions,
-  reducerHandlers,
   defaultColumn,
   getFirstDefined,
   mergeProps,
   applyPropHooks,
+  useGetLatest,
 } from '../utils'
 
-const pluginName = 'useResizeColumns'
-
 // Default Column
 defaultColumn.canResize = true
 
@@ -19,8 +15,14 @@ actions.columnStartResizing = 'columnStartResizing'
 actions.columnResizing = 'columnResizing'
 actions.columnDoneResizing = 'columnDoneResizing'
 
-// Reducer
-reducerHandlers[pluginName] = (state, action) => {
+export const useResizeColumns = hooks => {
+  hooks.stateReducers.push(reducer)
+  hooks.useInstanceBeforeDimensions.push(useInstanceBeforeDimensions)
+}
+
+useResizeColumns.pluginName = 'useResizeColumns'
+
+function reducer(state, action) {
   if (action.type === actions.init) {
     return {
       columnResizing: {
@@ -85,12 +87,6 @@ reducerHandlers[pluginName] = (state, action) => {
   }
 }
 
-export const useResizeColumns = hooks => {
-  hooks.useInstanceBeforeDimensions.push(useInstanceBeforeDimensions)
-}
-
-useResizeColumns.pluginName = pluginName
-
 const useInstanceBeforeDimensions = instance => {
   instance.hooks.getResizerProps = []
 
@@ -142,8 +138,7 @@ const useInstanceBeforeDimensions = instance => {
   }
 
   // use reference to avoid memory leak in #1608
-  const instanceRef = React.useRef()
-  instanceRef.current = instance
+  const getInstance = useGetLatest(instance)
 
   flatHeaders.forEach(header => {
     const canResize = getFirstDefined(
@@ -167,9 +162,9 @@ const useInstanceBeforeDimensions = instance => {
             draggable: false,
           },
           applyPropHooks(
-            instanceRef.current.hooks.getResizerProps,
+            getInstance().hooks.getResizerProps,
             header,
-            instanceRef.current
+            getInstance()
           ),
           userProps
         )

src/plugin-hooks/useRowSelect.js

@@ -2,11 +2,11 @@ import React from 'react'
 
 import {
   actions,
-  reducerHandlers,
   mergeProps,
   applyPropHooks,
   ensurePluginOrder,
-  safeUseLayoutEffect,
+  useGetLatest,
+  useMountedLayoutEffect,
 } from '../utils'
 
 const pluginName = 'useRowSelect'
@@ -16,8 +16,18 @@ actions.resetSelectedRows = 'resetSelectedRows'
 actions.toggleRowSelectedAll = 'toggleRowSelectedAll'
 actions.toggleRowSelected = 'toggleRowSelected'
 
-// Reducer
-reducerHandlers[pluginName] = (state, action) => {
+export const useRowSelect = hooks => {
+  hooks.getToggleRowSelectedProps = []
+  hooks.getToggleAllRowsSelectedProps = []
+
+  hooks.stateReducers.push(reducer)
+  hooks.useRows.push(useRows)
+  hooks.useInstance.push(useInstance)
+}
+
+useRowSelect.pluginName = pluginName
+
+function reducer(state, action, previousState, instanceRef) {
   if (action.type === actions.init) {
     return {
       selectedRowPaths: new Set(),
@@ -33,12 +43,8 @@ reducerHandlers[pluginName] = (state, action) => {
   }
 
   if (action.type === actions.toggleRowSelectedAll) {
-    const {
-      selected,
-      instanceRef: {
-        current: { isAllRowsSelected, flatRowPaths },
-      },
-    } = action
+    const { selected } = action
+    const { isAllRowsSelected, flatRowPaths } = instanceRef.current
 
     const selectAll =
       typeof selected !== 'undefined' ? selected : !isAllRowsSelected
@@ -50,13 +56,8 @@ reducerHandlers[pluginName] = (state, action) => {
   }
 
   if (action.type === actions.toggleRowSelected) {
-    const {
-      path,
-      selected,
-      instanceRef: {
-        current: { flatRowPaths },
-      },
-    } = action
+    const { path, selected } = action
+    const { flatRowPaths } = instanceRef.current
 
     const key = path.join('.')
     const childRowPrefixKey = [key, '.'].join('')
@@ -116,15 +117,6 @@ reducerHandlers[pluginName] = (state, action) => {
   }
 }
 
-export const useRowSelect = hooks => {
-  hooks.getToggleRowSelectedProps = []
-  hooks.getToggleAllRowsSelectedProps = []
-  hooks.useRows.push(useRows)
-  hooks.useInstance.push(useInstance)
-}
-
-useRowSelect.pluginName = pluginName
-
 function useRows(rows, instance) {
   const {
     state: { selectedRowPaths },
@@ -147,15 +139,14 @@ function useRows(rows, instance) {
   return rows
 }
 
-const defaultGetResetSelectedRowPathsDeps = ({ data }) => [data]
-
 function useInstance(instance) {
   const {
+    data,
     hooks,
     manualRowSelectedKey = 'isSelected',
     plugins,
     flatRows,
-    getResetSelectedRowPathsDeps = defaultGetResetSelectedRowPathsDeps,
+    autoResetSelectedRows = true,
     state: { selectedRowPaths },
     dispatch,
   } = instance
@@ -177,19 +168,13 @@ function useInstance(instance) {
     }
   }
 
-  // Bypass any effects from firing when this changes
-  const isMountedRef = React.useRef()
-  safeUseLayoutEffect(() => {
-    if (isMountedRef.current) {
+  const getAutoResetSelectedRows = useGetLatest(autoResetSelectedRows)
+
+  useMountedLayoutEffect(() => {
+    if (getAutoResetSelectedRows()) {
       dispatch({ type: actions.resetSelectedRows })
     }
-    isMountedRef.current = true
-  }, [
-    dispatch,
-    ...(getResetSelectedRowPathsDeps
-      ? getResetSelectedRowPathsDeps(instance)
-      : []),
-  ])
+  }, [dispatch, data])
 
   const toggleRowSelectedAll = selected =>
     dispatch({ type: actions.toggleRowSelectedAll, selected })

src/plugin-hooks/useRowState.js

@@ -2,19 +2,23 @@ import React from 'react'
 
 import {
   actions,
-  reducerHandlers,
   functionalUpdate,
-  safeUseLayoutEffect,
+  useMountedLayoutEffect,
+  useGetLatest,
 } from '../utils'
 
-const pluginName = 'useRowState'
-
 // Actions
 actions.setRowState = 'setRowState'
 actions.resetRowState = 'resetRowState'
 
-// Reducer
-reducerHandlers[pluginName] = (state, action) => {
+export const useRowState = hooks => {
+  hooks.stateReducers.push(reducer)
+  hooks.useInstance.push(useInstance)
+}
+
+useRowState.pluginName = 'useRowState'
+
+function reducer(state, action) {
   if (action.type === actions.init) {
     return {
       rowState: {},
@@ -44,20 +48,13 @@ reducerHandlers[pluginName] = (state, action) => {
   }
 }
 
-export const useRowState = hooks => {
-  hooks.useInstance.push(useInstance)
-}
-
-useRowState.pluginName = pluginName
-
-const defaultGetResetRowStateDeps = ({ data }) => [data]
-
 function useInstance(instance) {
   const {
     hooks,
     initialRowStateAccessor,
-    getResetRowStateDeps = defaultGetResetRowStateDeps,
+    autoResetRowState = true,
     state: { rowState },
+    data,
     dispatch,
   } = instance
 
@@ -94,19 +91,13 @@ function useInstance(instance) {
     [setRowState]
   )
 
-  const rowsMountedRef = React.useRef()
+  const getAutoResetRowState = useGetLatest(autoResetRowState)
 
-  // When data changes, reset row and cell state
-  safeUseLayoutEffect(() => {
-    if (rowsMountedRef.current) {
+  useMountedLayoutEffect(() => {
+    if (getAutoResetRowState()) {
       dispatch({ type: actions.resetRowState })
     }
-
-    rowsMountedRef.current = true
-  }, [
-    dispatch,
-    ...(getResetRowStateDeps ? getResetRowStateDeps(instance) : []),
-  ])
+  }, [data])
 
   hooks.prepareRow.push(row => {
     const pathKey = row.path.join('.')

src/plugin-hooks/useSortBy.js

@@ -2,28 +2,36 @@ import React from 'react'
 
 import {
   actions,
-  reducerHandlers,
   ensurePluginOrder,
   defaultColumn,
-  safeUseLayoutEffect,
   mergeProps,
   applyPropHooks,
   getFirstDefined,
   defaultOrderByFn,
   isFunction,
+  useGetLatest,
+  useMountedLayoutEffect,
 } from '../utils'
 
 import * as sortTypes from '../sortTypes'
 
-const pluginName = 'useSortBy'
-
 // Actions
 actions.resetSortBy = 'resetSortBy'
 actions.toggleSortBy = 'toggleSortBy'
 actions.clearSortBy = 'clearSortBy'
 
+defaultColumn.sortType = 'alphanumeric'
+defaultColumn.sortDescFirst = false
+
+export const useSortBy = hooks => {
+  hooks.stateReducers.push(reducer)
+  hooks.useInstance.push(useInstance)
+}
+
+useSortBy.pluginName = 'useSortBy'
+
 // Reducer
-reducerHandlers[pluginName] = (state, action) => {
+function reducer(state, action, previousState, instanceRef) {
   if (action.type === actions.init) {
     return {
       sortBy: [],
@@ -40,7 +48,7 @@ reducerHandlers[pluginName] = (state, action) => {
 
   if (action.type === actions.clearSortBy) {
     const { sortBy } = state
-    const newSortBy = sortBy.filter(d => d.id !== action.columnID)
+    const newSortBy = sortBy.filter(d => d.id !== action.columnId)
 
     return {
       ...state,
@@ -49,20 +57,16 @@ reducerHandlers[pluginName] = (state, action) => {
   }
 
   if (action.type === actions.toggleSortBy) {
+    const { columnId, desc, multi } = action
+
     const {
-      columnId,
-      desc,
-      multi,
-      instanceRef: {
-        current: {
-          flatColumns,
-          disableMultiSort,
-          disableSortRemove,
-          disableMultiRemove,
-          maxMultiSortColCount = Number.MAX_SAFE_INTEGER,
-        },
-      },
-    } = action
+      flatColumns,
+      disableMultiSort,
+      disableSortRemove,
+      disableMultiRemove,
+      maxMultiSortColCount = Number.MAX_SAFE_INTEGER,
+    } = instanceRef.current
+
     const { sortBy } = state
 
     // Find the column for this columnId
@@ -149,23 +153,14 @@ reducerHandlers[pluginName] = (state, action) => {
   }
 }
 
-defaultColumn.sortType = 'alphanumeric'
-defaultColumn.sortDescFirst = false
-
-export const useSortBy = hooks => {
-  hooks.useInstance.push(useInstance)
-}
-
-useSortBy.pluginName = pluginName
-
 function useInstance(instance) {
   const {
-    debug,
+    data,
     rows,
     flatColumns,
     orderByFn = defaultOrderByFn,
     sortTypes: userSortTypes,
-    manualSorting,
+    manualSortBy,
     defaultCanSort,
     disableSortBy,
     isMultiSortEvent = e => e.shiftKey,
@@ -174,30 +169,20 @@ function useInstance(instance) {
     state: { sortBy },
     dispatch,
     plugins,
-    getResetSortByDeps = false,
+    autoResetSortBy = true,
   } = instance
 
   ensurePluginOrder(plugins, ['useFilters'], 'useSortBy', [])
   // Add custom hooks
   hooks.getSortByToggleProps = []
 
-  // Bypass any effects from firing when this changes
-  const isMountedRef = React.useRef()
-  safeUseLayoutEffect(() => {
-    if (isMountedRef.current) {
-      dispatch({ type: actions.resetSortBy })
-    }
-    isMountedRef.current = true
-  }, [dispatch, ...(getResetSortByDeps ? getResetSortByDeps(instance) : [])])
-
   // Updates sorting based on a columnId, desc flag and multi flag
   const toggleSortBy = (columnId, desc, multi) => {
     dispatch({ type: actions.toggleSortBy, columnId, desc, multi })
   }
 
   // use reference to avoid memory leak in #1608
-  const instanceRef = React.useRef()
-  instanceRef.current = instance
+  const getInstance = useGetLatest(instance)
 
   // Add the getSortByToggleProps method to columns and headers
   flatHeaders.forEach(column => {
@@ -235,19 +220,19 @@ function useInstance(instance) {
                 e.persist()
                 column.toggleSortBy(
                   undefined,
-                  !instanceRef.current.disableMultiSort && isMultiSortEvent(e)
+                  !getInstance().disableMultiSort && isMultiSortEvent(e)
                 )
               }
             : undefined,
           style: {
             cursor: canSort ? 'pointer' : undefined,
           },
-          title: 'Toggle SortBy',
+          title: canSort ? 'Toggle SortBy' : undefined,
         },
         applyPropHooks(
-          instanceRef.current.hooks.getSortByToggleProps,
+          getInstance().hooks.getSortByToggleProps,
           column,
-          instanceRef.current
+          getInstance()
         ),
         props
       )
@@ -260,11 +245,9 @@ function useInstance(instance) {
   })
 
   const sortedRows = React.useMemo(() => {
-    if (manualSorting || !sortBy.length) {
+    if (manualSortBy || !sortBy.length) {
       return rows
     }
-    if (process.env.NODE_ENV !== 'production' && debug)
-      console.time('getSortedRows')
 
     // Filter out sortBys that correspond to non existing columns
     const availableSortBy = sortBy.filter(sort =>
@@ -335,19 +318,16 @@ function useInstance(instance) {
       return sortedData
     }
 
-    if (process.env.NODE_ENV !== 'production' && debug)
-      console.timeEnd('getSortedRows')
-
     return sortData(rows)
-  }, [
-    manualSorting,
-    sortBy,
-    debug,
-    rows,
-    flatColumns,
-    orderByFn,
-    userSortTypes,
-  ])
+  }, [manualSortBy, sortBy, rows, flatColumns, orderByFn, userSortTypes])
+
+  const getAutoResetSortBy = useGetLatest(autoResetSortBy)
+
+  useMountedLayoutEffect(() => {
+    if (getAutoResetSortBy()) {
+      dispatch({ type: actions.resetSortBy })
+    }
+  }, [manualSortBy ? null : data])
 
   return {
     ...instance,

src/publicUtils.js

@@ -0,0 +1,179 @@
+import React from 'react'
+
+export const actions = {
+  init: 'init',
+}
+
+export const defaultColumn = {
+  Cell: ({ cell: { value = '' } }) => String(value),
+  width: 150,
+  minWidth: 0,
+  maxWidth: Number.MAX_SAFE_INTEGER,
+}
+
+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'
+      const sortInt = sortFn(rowA, rowB)
+      if (sortInt !== 0) {
+        return desc ? -sortInt : sortInt
+      }
+    }
+    return dirs[0] ? rowA.index - rowB.index : rowB.index - rowA.index
+  })
+}
+
+export function defaultGroupByFn(rows, columnId) {
+  return rows.reduce((prev, row, i) => {
+    // TODO: Might want to implement a key serializer here so
+    // irregular column values can still be grouped if needed?
+    const resKey = `${row.values[columnId]}`
+    prev[resKey] = Array.isArray(prev[resKey]) ? prev[resKey] : []
+    prev[resKey].push(row)
+    return prev
+  }, {})
+}
+
+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(' '),
+    }
+  })
+
+  if (props.className === '') {
+    delete props.className
+  }
+
+  return props
+}
+
+export const applyHooks = (hooks, initial, ...args) =>
+  hooks.reduce((prev, next) => {
+    const nextValue = next(prev, ...args)
+    if (typeof nextValue === 'undefined') {
+      throw new Error(
+        'React Table: A hook just returned undefined! This is not allowed.'
+      )
+    }
+    return nextValue
+  }, initial)
+
+export const applyPropHooks = (hooks, ...args) =>
+  hooks.reduce((prev, next) => mergeProps(prev, next(...args)), {})
+
+export function ensurePluginOrder(plugins, befores, pluginName, afters) {
+  const pluginIndex = plugins.findIndex(
+    plugin => plugin.pluginName === pluginName
+  )
+
+  if (pluginIndex === -1) {
+    throw new Error(`The plugin ${pluginName} was not found in the plugin list!
+This usually means you need to need to name your plugin hook by setting the 'pluginName' property of the hook function, eg:
+
+  ${pluginName}.pluginName = '${pluginName}'
+`)
+  }
+
+  befores.forEach(before => {
+    const beforeIndex = plugins.findIndex(
+      plugin => plugin.pluginName === before
+    )
+    if (beforeIndex > -1 && beforeIndex > pluginIndex) {
+      throw new Error(
+        `React Table: The ${pluginName} plugin hook must be placed after the ${before} plugin hook!`
+      )
+    }
+  })
+
+  afters.forEach(after => {
+    const afterIndex = plugins.findIndex(plugin => plugin.pluginName === after)
+    if (afterIndex > -1 && afterIndex < pluginIndex) {
+      throw new Error(
+        `React Table: The ${pluginName} plugin hook must be placed before the ${after} plugin hook!`
+      )
+    }
+  })
+}
+
+export function functionalUpdate(updater, old) {
+  return typeof updater === 'function' ? updater(old) : updater
+}
+
+export function useGetLatest(obj) {
+  const ref = React.useRef()
+  ref.current = obj
+
+  return React.useCallback(() => ref.current, [])
+}
+
+// SSR has issues with useLayoutEffect still, so use useEffect during SSR
+export const safeUseLayoutEffect =
+  typeof document !== 'undefined' ? React.useLayoutEffect : React.useEffect
+
+export function useMountedLayoutEffect(fn, deps) {
+  const mountedRef = React.useRef(false)
+
+  safeUseLayoutEffect(() => {
+    if (mountedRef.current) {
+      fn()
+    }
+    mountedRef.current = true
+    // eslint-disable-next-line
+  }, deps)
+}
+
+export default function useAsyncDebounce(defaultFn, defaultWait = 0) {
+  const debounceRef = React.useRef({})
+  debounceRef.current.defaultFn = defaultFn
+  debounceRef.current.defaultWait = defaultWait
+
+  const debounce = React.useCallback(
+    async (
+      fn = debounceRef.current.defaultFn,
+      wait = debounceRef.current.defaultWait
+    ) => {
+      if (!debounceRef.current.promise) {
+        debounceRef.current.promise = new Promise(resolve => {
+          debounceRef.current.resolve = resolve
+        })
+      }
+
+      if (debounceRef.current.timeout) {
+        clearTimeout(debounceRef.current.timeout)
+      }
+
+      debounceRef.current.timeout = setTimeout(async () => {
+        delete debounceRef.current.timeout
+        try {
+          debounceRef.current.resolve(await fn())
+        } catch (err) {
+          debounceRef.current.reject(err)
+        } finally {
+          delete debounceRef.current.promise
+        }
+      }, wait)
+
+      return debounceRef.current.promise
+    },
+    []
+  )
+
+  return debounce
+}
+
+export function useConsumeHookGetter(hooks, hookName) {
+  const getter = useGetLatest(hooks[hookName])
+  hooks[hookName] = undefined
+  return getter
+}

src/utils.js

@@ -1,23 +1,7 @@
 import React from 'react'
+import { defaultColumn } from './publicUtils'
 
-export const actions = {
-  init: 'init',
-}
-
-export const reducerHandlers = {}
-
-export const defaultColumn = {
-  Cell: ({ cell: { value = '' } }) => String(value),
-  width: 150,
-  minWidth: 0,
-  maxWidth: Number.MAX_SAFE_INTEGER,
-}
-
-// SSR has issues with useLayoutEffect still, so use useEffect during SSR
-export const safeUseLayoutEffect =
-  typeof window !== 'undefined' && process.env.NODE_ENV === 'production'
-    ? React.useLayoutEffect
-    : React.useEffect
+export * from './publicUtils'
 
 // Find the depth of the columns
 export function findMaxDepth(columns, depth = 0) {
@@ -29,13 +13,7 @@ export function findMaxDepth(columns, depth = 0) {
   }, 0)
 }
 
-export function decorateColumn(
-  column,
-  userDefaultColumn,
-  parent,
-  depth,
-  index
-) {
+function decorateColumn(column, userDefaultColumn, parent, depth, index) {
   // Apply the userDefaultColumn
   column = { ...defaultColumn, ...userDefaultColumn, ...column }
 
@@ -65,6 +43,7 @@ export function decorateColumn(
   column = {
     // Make sure there is a fallback header, just in case
     Header: () => <>&nbsp;</>,
+    Footer: () => <>&nbsp;</>,
     ...column,
     // Materialize and override this stuff
     id,
@@ -181,12 +160,24 @@ export function makeHeaderGroups(flatColumns, defaultColumn) {
   return headerGroups.reverse()
 }
 
+const pathObjCache = new Map()
+
 export function getBy(obj, path, def) {
   if (!path) {
     return obj
   }
-  const pathObj = makePathArray(path)
+  const cacheKey = typeof path === 'function' ? path : JSON.stringify(path)
+
+  const pathObj =
+    pathObjCache.get(cacheKey) ||
+    (() => {
+      const pathObj = makePathArray(path)
+      pathObjCache.set(cacheKey, pathObj)
+      return pathObj
+    })()
+
   let val
+
   try {
     val = pathObj.reduce((cursor, pathPart) => cursor[pathPart], obj)
   } catch (e) {
@@ -195,20 +186,6 @@ export function getBy(obj, path, def) {
   return typeof val !== 'undefined' ? val : def
 }
 
-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'
-      const sortInt = sortFn(rowA, rowB)
-      if (sortInt !== 0) {
-        return desc ? -sortInt : sortInt
-      }
-    }
-    return dirs[0] ? rowA.index - rowB.index : rowB.index - rowA.index
-  })
-}
-
 export function getFirstDefined(...args) {
   for (let i = 0; i < args.length; i += 1) {
     if (typeof args[i] !== 'undefined') {
@@ -217,17 +194,6 @@ export function getFirstDefined(...args) {
   }
 }
 
-export function defaultGroupByFn(rows, columnId) {
-  return rows.reduce((prev, row, i) => {
-    // TODO: Might want to implement a key serializer here so
-    // irregular column values can still be grouped if needed?
-    const resKey = `${row.values[columnId]}`
-    prev[resKey] = Array.isArray(prev[resKey]) ? prev[resKey] : []
-    prev[resKey].push(row)
-    return prev
-  }, {})
-}
-
 export function getElementDimensions(element) {
   const rect = element.getBoundingClientRect()
   const style = window.getComputedStyle(element)
@@ -275,56 +241,6 @@ function isReactComponent(component) {
   return isClassComponent(component) || isFunctionComponent(component)
 }
 
-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(' '),
-    }
-  })
-
-  if (props.className === '') {
-    delete props.className
-  }
-
-  return props
-}
-
-export const applyHooks = (hooks, initial, ...args) =>
-  hooks.reduce((prev, next) => {
-    const nextValue = next(prev, ...args)
-    if (typeof nextValue === 'undefined') {
-      throw new Error(
-        'React Table: A hook just returned undefined! This is not allowed.'
-      )
-    }
-    return nextValue
-  }, initial)
-
-export const applyPropHooks = (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)
-}
-
 export function isFunction(a) {
   if (typeof a === 'function') {
     return a
@@ -349,40 +265,6 @@ export function flattenBy(columns, childKey) {
   return flatColumns
 }
 
-export function ensurePluginOrder(plugins, befores, pluginName, afters) {
-  const pluginIndex = plugins.findIndex(
-    plugin => plugin.pluginName === pluginName
-  )
-
-  if (pluginIndex === -1) {
-    throw new Error(`The plugin ${pluginName} was not found in the plugin list!
-This usually means you need to need to name your plugin hook by setting the 'pluginName' property of the hook function, eg:
-
-  ${pluginName}.pluginName = '${pluginName}'
-`)
-  }
-
-  befores.forEach(before => {
-    const beforeIndex = plugins.findIndex(
-      plugin => plugin.pluginName === before
-    )
-    if (beforeIndex > -1 && beforeIndex > pluginIndex) {
-      throw new Error(
-        `React Table: The ${pluginName} plugin hook must be placed after the ${before} plugin hook!`
-      )
-    }
-  })
-
-  afters.forEach(after => {
-    const afterIndex = plugins.findIndex(plugin => plugin.pluginName === after)
-    if (afterIndex > -1 && afterIndex < pluginIndex) {
-      throw new Error(
-        `React Table: The ${pluginName} plugin hook must be placed before the ${after} plugin hook!`
-      )
-    }
-  })
-}
-
 export function expandRows(
   rows,
   { manualExpandedKey, expanded, expandSubRows = true }
@@ -410,12 +292,11 @@ export function expandRows(
   return expandedRows
 }
 
-export function functionalUpdate(updater, old) {
-  return typeof updater === 'function' ? updater(old) : updater
-}
-
 //
 
+const reOpenBracket = /\[/g
+const reCloseBracket = /\]/g
+
 function makePathArray(obj) {
   return (
     flattenDeep(obj)
@@ -424,8 +305,8 @@ function makePathArray(obj) {
       // join parts using period
       .join('.')
       // replace brackets with periods
-      .replace(/\[/g, '.')
-      .replace(/\]/g, '')
+      .replace(reOpenBracket, '.')
+      .replace(reCloseBracket, '')
       // split it back out on periods
       .split('.')
   )