v7.0.0-beta.8

Added instance.selectedFlatRows to know which row objects are currently selecte

README.md

@@ -43,6 +43,8 @@ Hooks for building **lightweight, fast and extendable datagrids** for React
 - Row Expansion
 - Column Ordering
 - Animatable
+- Virtualizable
+- Resizable
 - Server-side/controlled data/state
 - Extensible via hook-based plugin system
 - <a href="https://medium.com/@tannerlinsley/why-i-wrote-react-table-and-the-problems-it-has-solved-for-nozzle-others-445c4e93d4a8#.axza4ixba" target="\_parent">"Why I wrote React Table and the problems it has solved for Nozzle.io"</a> by Tanner Linsley

docs/api.md

@@ -19,6 +19,7 @@ React Table is essentially a compatible collection of **custom React hooks**:
   - Layout Hooks
     - [`useBlockLayout`](#useBlockLayout)
     - [`useAbsoluteLayout`](#useAbsoluteLayout)
+    - [`useResizeColumns`](#useResizeColumns)
   - Utility Hooks
     - [`useTableState`](#useTableState)
 - 3rd Party Plugin Hooks
@@ -119,7 +120,7 @@ The following options are supported via the main options object passed to `useTa
   - A flag to turn on debug mode.
   - Defaults to `false`
 
-### `column` Options
+### Column Options
 
 The following options are supported on any column object you can pass to `columns`.
 
@@ -208,10 +209,6 @@ The following properties are available on the table instance returned from `useT
   - **Required**
   - This function is responsible for lazily preparing a row for rendering. Any row that you intend to render in your table needs to be passed to this function **before every render**.
   - **Why?** Since table data could potentially be very large, it can become very expensive to compute all of the necessary state for every row to be rendered regardless if it actually is rendered or not (for example if you are paginating or virtualizing the rows, you may only have a few rows visible at any given moment). This function allows only the rows you intend to display to be computed and prepped with the correct state.
-- `rowPaths: Array<string>`
-  - An array containing the stringified `path` of every original row in the table. eg. If a row has a path of `[0, 3, 2]`, its stringified path would be `0.3.2`.
-  - This array is used by many plugin hooks including `useRowSelect` to manage row selection state
-  - Only rows that exist on the original `data` array will have a path in this array. Rows created by `useGroupBy`'s aggregations and grouping are not included in this array, since they do not reference an original data row.
 - `flatRows: Array<Row>`
   - An array of all rows, including subRows which have been flattened into the order in which they were detected (depth first)
   - This can be helpful in calculating total row counts that must include subRows
@@ -317,82 +314,8 @@ The following additional properties are available on every `Cell` object returne
 
 ### Example
 
-```js
-function App() {
-  const columns = React.useMemo(
-    () => [
-      {
-        Header: 'Name',
-        columns: [
-          {
-            Header: 'First Name',
-            accessor: 'firstName',
-          },
-          {
-            Header: 'Last Name',
-            accessor: 'lastName',
-          },
-        ],
-      },
-    ],
-    []
-  )
-
-  const data = [
-    {
-      firstName: 'Tanner',
-      lastName: 'Linsley',
-    },
-    {
-      firstName: 'Shawn',
-      lastName: 'Wang',
-    },
-    {
-      firstName: 'Kent C.',
-      lastName: 'Dodds',
-    },
-    {
-      firstName: 'Ryan',
-      lastName: 'Florence',
-    },
-  ]
-
-  return <MyTable columns={columns} data={data} />
-}
-
-function MyTable({ columns, data }) {
-  const { getTableProps, headerGroups, rows, prepareRow } = useTable({
-    columns,
-    data,
-  })
-
-  return (
-    <table {...getTableProps()}>
-      <thead>
-        {headerGroups.map(headerGroup => (
-          <tr {...headerGroup.getHeaderGroupProps()}>
-            {headerGroup.headers.map(column => (
-              <th {...column.getHeaderProps()}>{column.render('Header')}</th>
-            ))}
-          </tr>
-        ))}
-      </thead>
-      <tbody {...getTableBodyProps()}>
-        {rows.map(
-          (row, i) =>
-            prepareRow(row) || (
-              <tr {...row.getRowProps()}>
-                {row.cells.map(cell => {
-                  return <td {...cell.getCellProps()}>{cell.render('Cell')}</td>
-                })}
-              </tr>
-            )
-        )}
-      </tbody>
-    </table>
-  )
-}
-```
+- [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)
 
 # `useSortBy`
 
@@ -503,63 +426,8 @@ The following properties are available on every `Column` object returned by the
 
 ### Example
 
-```js
-function Table({ columns, data }) {
-  // Set some default sorting state. For this an additional import of useTableState is needed
-  const state = useTableState({ sortBy: [{ id: 'firstName', desc: true }] })
-
-  const { getTableProps, headerGroups, rows, prepareRow } = useTable(
-    {
-      columns,
-      data,
-      state,
-    },
-    useSortBy // Use the sortBy hook
-  )
-
-  return (
-    <table {...getTableProps()}>
-      <thead>
-        {headerGroups.map(headerGroup => (
-          <tr {...headerGroup.getHeaderGroupProps()}>
-            {headerGroup.headers.map(column => (
-              // Add the sorting props to control sorting. For this example
-              // we can add them into the header props
-              <th {...column.getHeaderProps(column.getSortByToggleProps())}>
-                {column.render('Header')}
-                <span>
-                  {/* Add a sort direction indicator */}
-                  <span>
-                    {column.isSorted
-                      ? column.isSortedDesc
-                        ? ' 🔽'
-                        : ' 🔼'
-                      : ''}
-                  </span>
-                  {/* Add a sort index indicator */}
-                  <span>({column.isSorted ? column.sortedIndex + 1 : ''})</span>
-                </span>
-              </th>
-            ))}
-          </tr>
-        ))}
-      </thead>
-      <tbody {...getTableBodyProps()}>
-        {rows.map(
-          (row, i) =>
-            prepareRow(row) || (
-              <tr {...row.getRowProps()}>
-                {row.cells.map(cell => {
-                  return <td {...cell.getCellProps()}>{cell.render('Cell')}</td>
-                })}
-              </tr>
-            )
-        )}
-      </tbody>
-    </table>
-  )
-}
-```
+- [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`
 
@@ -643,49 +511,8 @@ The following properties are available on every `Column` object returned by the
 
 ### Example
 
-```js
-// A great library for fuzzy filtering/sorting items
-import matchSorter from 'match-sorter'
-
-const state = useTableState({ filters: { firstName: 'tanner' } })
-
-const filterTypes = React.useMemo(() => ({
-  // Add a new fuzzyText filter type.
-  fuzzyText: (rows, id, filterValue) => {
-    return matchSorter(rows, filterValue, { keys: [row => row[id] })
-  },
-  // Or, override the default text filter to use
-  // "startWith"
-  text: (rows, id, filterValue) => {
-    return rows.filter(row => {
-      const rowValue = row.values[id]
-      return rowValue !== undefined
-        ? String(rowValue)
-            .toLowerCase()
-            .startsWith(String(filterValue).toLowerCase())
-        : true
-    })
-  }
-}), [matchSorter])
-
-// Override the default column filter to be our new `fuzzyText` filter type
-const defaultColumn = React.useMemo(() => ({
-  filter: 'fuzzyText'
-}))
-
-const { rows } = useTable(
-  {
-    // state[0].groupBy === ['firstName']
-    state,
-    manualFilters: false,
-    disableFilters: false,
-    // Pass our custom filter types
-    filterTypes,
-    defaultColumn
-  },
-  useFilters
-)
-```
+- [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)
 
 # `useGroupBy`
 
@@ -797,168 +624,8 @@ The following additional properties are available on every `Cell` object returne
 
 ### Example
 
-```js
-function Table({ columns, data }) {
-  const {
-    getTableProps,
-    headerGroups,
-    rows,
-    prepareRow,
-    state: [{ groupBy, expanded }],
-  } = useTable(
-    {
-      columns,
-      data,
-    },
-    useGroupBy,
-    useExpanded // useGroupBy would be pretty useless without useExpanded ;)
-  )
-
-  // We don't want to render all 2000 rows for this example, so cap
-  // it at 20 for this use case
-  const firstPageRows = rows.slice()
-
-  return (
-    <table {...getTableProps()}>
-      <thead>
-        {headerGroups.map(headerGroup => (
-          <tr {...headerGroup.getHeaderGroupProps()}>
-            {headerGroup.headers.map(column => (
-              <th {...column.getHeaderProps()}>
-                {column.canGroupBy ? (
-                  // If the column can be grouped, let's add a toggle
-                  <span {...column.getGroupByToggleProps()}>
-                    {column.grouped ? '🛑' : '👊'}
-                  </span>
-                ) : null}
-                {column.render('Header')}
-              </th>
-            ))}
-          </tr>
-        ))}
-      </thead>
-      <tbody {...getTableBodyProps()}>
-        {firstPageRows.map(
-          (row, i) =>
-            prepareRow(row) || (
-              <tr {...row.getRowProps()}>
-                {row.cells.map(cell => {
-                  return (
-                    <td {...cell.getCellProps()}>
-                      {cell.grouped ? (
-                        // If it's a grouped cell, add an expander and row count
-                        <>
-                          <span
-                            style={{
-                              cursor: 'pointer',
-                            }}
-                            onClick={() => row.toggleExpanded()}
-                          >
-                            {row.isExpanded ? '👇' : '👉'}
-                          </span>
-                          {cell.render('Cell')} ({row.subRows.length})
-                        </>
-                      ) : cell.aggregated ? (
-                        // If the cell is aggregated, use the Aggregated
-                        // renderer for cell
-                        cell.render('Aggregated')
-                      ) : cell.repeatedValue ? null : ( // For cells with repeated values, render null
-                        // Otherwise, just render the regular cell
-                        cell.render('Cell')
-                      )}
-                    </td>
-                  )
-                })}
-              </tr>
-            )
-        )}
-      </tbody>
-    </table>
-  )
-}
-
-// This is a custom aggregator that
-// takes in an array of values and
-// returns the rounded median
-function roundedMedian(values) {
-  let min = values[0] || ''
-  let max = values[0] || ''
-
-  values.forEach(value => {
-    min = Math.min(min, value)
-    max = Math.max(max, value)
-  })
-
-  return Math.round((min + max) / 2)
-}
-
-function App() {
-  const columns = React.useMemo(
-    () => [
-      {
-        Header: 'Name',
-        columns: [
-          {
-            Header: 'First Name',
-            accessor: 'firstName',
-            // Use a two-stage aggregator here to first
-            // count the total rows being aggregated,
-            // then sum any of those counts if they are
-            // aggregated further
-            aggregate: ['sum', 'count'],
-            Aggregated: ({ cell: { value } }) => `${value} Names`,
-          },
-          {
-            Header: 'Last Name',
-            accessor: 'lastName',
-            // Use another two-stage aggregator here to
-            // first count the UNIQUE values from the rows
-            // being aggregated, then sum those counts if
-            // they are aggregated further
-            aggregate: ['sum', 'uniqueCount'],
-            Aggregated: ({ cell: { value } }) => `${value} Unique Names`,
-          },
-        ],
-      },
-      {
-        Header: 'Info',
-        columns: [
-          {
-            Header: 'Age',
-            accessor: 'age',
-            // Aggregate the average age of visitors
-            aggregate: 'average',
-            Aggregated: ({ cell: { value } }) => `${value} (avg)`,
-          },
-          {
-            Header: 'Visits',
-            accessor: 'visits',
-            // Aggregate the sum of all visits
-            aggregate: 'sum',
-            Aggregated: ({ cell: { value } }) => `${value} (total)`,
-          },
-          {
-            Header: 'Status',
-            accessor: 'status',
-          },
-          {
-            Header: 'Profile Progress',
-            accessor: 'progress',
-            // Use our custom roundedMedian aggregator
-            aggregate: roundedMedian,
-            Aggregated: ({ cell: { value } }) => `${value} (med)`,
-          },
-        ],
-      },
-    ],
-    []
-  )
-
-  const data = React.useMemo(() => makeData(10000), [])
-
-  return <Table columns={columns} data={data} />
-}
-```
+- [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/grouping)
+- [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/grouping)
 
 # `useExpanded`
 
@@ -985,6 +652,11 @@ The following options are supported via the main options object passed to `useTa
   - Optional
   - Defaults to `expanded`
   - This string is used as the key to detect manual expanded state on any given row. For example, if a raw data row like `{ name: 'Tanner Linsley', friends: [...], expanded: true}` was detected, it would always be expanded, regardless of state.
+- `expandSubRows: Bool`
+  - Optional
+  - 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.
 
 ### Instance Properties
 
@@ -1005,126 +677,8 @@ The following additional properties are available on every `row` object returned
 
 ### Example
 
-```js
-function Table({ columns: userColumns, data }) {
-  const {
-    getTableProps,
-    headerGroups,
-    rows,
-    prepareRow,
-    state: [{ expanded }],
-  } = useTable(
-    {
-      columns: userColumns,
-      data,
-    },
-    useExpanded // Use the useExpanded plugin hook
-  )
-
-  return (
-    <>
-      <pre>
-        <code>{JSON.stringify({ expanded }, null, 2)}</code>
-      </pre>
-      <table {...getTableProps()}>
-        <thead>
-          {headerGroups.map(headerGroup => (
-            <tr {...headerGroup.getHeaderGroupProps()}>
-              {headerGroup.headers.map(column => (
-                <th {...column.getHeaderProps()}>{column.render('Header')}</th>
-              ))}
-            </tr>
-          ))}
-        </thead>
-        <tbody {...getTableBodyProps()}>
-          {rows.map(
-            (row, i) =>
-              prepareRow(row) || (
-                <tr {...row.getRowProps()}>
-                  {row.cells.map(cell => {
-                    return (
-                      <td {...cell.getCellProps()}>{cell.render('Cell')}</td>
-                    )
-                  })}
-                </tr>
-              )
-          )}
-        </tbody>
-      </table>
-      <br />
-      <div>Showing the first 20 results of {rows.length} rows</div>
-    </>
-  )
-}
-
-function App() {
-  const columns = React.useMemo(
-    () => [
-      {
-        // Build our expander column
-        Header: () => null, // No header, please
-        id: 'expander', // Make sure it has an ID
-        Cell: ({ row }) =>
-          // Use the row.canExpand and row.getExpandedToggleProps prop getter
-          // to build the toggle for expanding a row
-          row.canExpand ? (
-            <span
-              {...row.getExpandedToggleProps({
-                style: {
-                  // We can even use the row.depth property
-                  // and paddingLeft to indicate the depth
-                  // of the row
-                  paddingLeft: `${row.depth * 2}rem`,
-                },
-              })}
-            >
-              {row.isExpanded ? '👇' : '👉'}
-            </span>
-          ) : null,
-      },
-      {
-        Header: 'Name',
-        columns: [
-          {
-            Header: 'First Name',
-            accessor: 'firstName',
-          },
-          {
-            Header: 'Last Name',
-            accessor: 'lastName',
-          },
-        ],
-      },
-      {
-        Header: 'Info',
-        columns: [
-          {
-            Header: 'Age',
-            accessor: 'age',
-          },
-          {
-            Header: 'Visits',
-            accessor: 'visits',
-          },
-          {
-            Header: 'Status',
-            accessor: 'status',
-          },
-          {
-            Header: 'Profile Progress',
-            accessor: 'progress',
-          },
-        ],
-      },
-    ],
-    []
-  )
-
-  const data = React.useMemo(() => makeData(5, 5, 5), [])
-
-  return <Table columns={columns} data={data} />
-}
-```
+- [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/expanding)
+- [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/expanding)
 
 # `usePagination`
 
@@ -1199,178 +753,12 @@ The following values are provided to the table `instance`:
 
 ### Example
 
-```js
-function Table({ columns, data }) {
-  // Use the state and functions returned from useTable to build your UI
-  const {
-    getTableProps,
-    headerGroups,
-    prepareRow,
-    page, // Instead of using 'rows', we'll use page,
-    // which has only the rows for the active page
-
-    // The rest of these things are super handy, too ;)
-    canPreviousPage,
-    canNextPage,
-    pageOptions,
-    pageCount,
-    gotoPage,
-    nextPage,
-    previousPage,
-    setPageSize,
-    state: [{ pageIndex, pageSize }],
-  } = useTable(
-    {
-      columns,
-      data,
-    },
-    usePagination
-  )
-
-  // Render the UI for your table
-  return (
-    <>
-      <pre>
-        <code>
-          {JSON.stringify(
-            {
-              pageIndex,
-              pageSize,
-              pageCount,
-              canNextPage,
-              canPreviousPage,
-            },
-            null,
-            2
-          )}
-        </code>
-      </pre>
-      <table {...getTableProps()}>
-        <thead>
-          {headerGroups.map(headerGroup => (
-            <tr {...headerGroup.getHeaderGroupProps()}>
-              {headerGroup.headers.map(column => (
-                <th {...column.getHeaderProps()}>{column.render('Header')}</th>
-              ))}
-            </tr>
-          ))}
-        </thead>
-        <tbody {...getTableBodyProps()}>
-          {page.map(
-            (row, i) =>
-              prepareRow(row) || (
-                <tr {...row.getRowProps()}>
-                  {row.cells.map(cell => {
-                    return (
-                      <td {...cell.getCellProps()}>{cell.render('Cell')}</td>
-                    )
-                  })}
-                </tr>
-              )
-          )}
-        </tbody>
-      </table>
-      {/* 
-        Pagination can be built however you'd like. 
-        This is just a very basic UI implementation:
-      */}
-      <div className="pagination">
-        <button onClick={() => gotoPage(0)} disabled={!canPreviousPage}>
-          {'<<'}
-        </button>{' '}
-        <button onClick={() => previousPage()} disabled={!canPreviousPage}>
-          {'<'}
-        </button>{' '}
-        <button onClick={() => nextPage()} disabled={!canNextPage}>
-          {'>'}
-        </button>{' '}
-        <button onClick={() => gotoPage(pageCount - 1)} disabled={!canNextPage}>
-          {'>>'}
-        </button>{' '}
-        <span>
-          Page{' '}
-          <strong>
-            {pageIndex + 1} of {pageOptions.length}
-          </strong>{' '}
-        </span>
-        <span>
-          | Go to page:{' '}
-          <input
-            type="number"
-            defaultValue={pageIndex + 1}
-            onChange={e => {
-              const page = e.target.value ? Number(e.target.value) - 1 : 0
-              gotoPage(page)
-            }}
-            style={{ width: '100px' }}
-          />
-        </span> <select
-          value={pageSize}
-          onChange={e => {
-            setPageSize(Number(e.target.value))
-          }}
-        >
-          {[10, 20, 30, 40, 50].map(pageSize => (
-            <option key={pageSize} value={pageSize}>
-              Show {pageSize}
-            </option>
-          ))}
-        </select>
-      </div>
-    </>
-  )
-}
-
-function App() {
-  const columns = React.useMemo(
-    () => [
-      {
-        Header: 'Name',
-        columns: [
-          {
-            Header: 'First Name',
-            accessor: 'firstName',
-          },
-          {
-            Header: 'Last Name',
-            accessor: 'lastName',
-          },
-        ],
-      },
-      {
-        Header: 'Info',
-        columns: [
-          {
-            Header: 'Age',
-            accessor: 'age',
-          },
-          {
-            Header: 'Visits',
-            accessor: 'visits',
-          },
-          {
-            Header: 'Status',
-            accessor: 'status',
-          },
-          {
-            Header: 'Profile Progress',
-            accessor: 'progress',
-          },
-        ],
-      },
-    ],
-    []
-  )
-
-  const data = React.useMemo(() => makeData(100000), [])
-
-  return (
-    <Styles>
-      <Table columns={columns} data={data} />
-    </Styles>
-  )
-}
-```
+- Basic Pagination
+  - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/pagination)
+  - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/pagination)
+- Controlled Pagination
+  - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/pagination)
+  - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/pagination)
 
 # `useTokenPagination (Coming Soon)`
 
@@ -1392,7 +780,7 @@ function App() {
 
 The following options are supported via the main options object passed to `useTable(options)`
 
-- `state[0].selectedRows: Array<RowPathKey>`
+- `state[0].selectedRowsPaths: Array<RowPathKey>`
   - Optional
   - Defaults to `[]`
   - If a row's path key (eg. a row path of `[1, 3, 2]` would have a path key of `1.3.2`) is found in this array, it will have a selected state.
@@ -1421,6 +809,8 @@ The following values are provided to the table `instance`:
 - `isAllRowsSelected: Bool`
   - Will be `true` if all rows are selected.
   - If at least one row is not selected, will be `false`
+- `selectedFlatRows: Array<Row>`
+  - The flat array of rows that are currently selected
 
 ### Row Properties
 
@@ -1434,123 +824,8 @@ The following additional properties are available on every **prepared** `row` ob
 
 ### Example
 
-```js
-function Table({ columns, data }) {
-  // Use the state and functions returned from useTable to build your UI
-  const {
-    getTableProps,
-    headerGroups,
-    rows,
-    prepareRow,
-    state: [{ selectedRows }],
-  } = useTable(
-    {
-      columns,
-      data,
-    },
-    useRowSelect
-  )
-
-  // Render the UI for your table
-  return (
-    <>
-      <table {...getTableProps()}>
-        <thead>
-          {headerGroups.map(headerGroup => (
-            <tr {...headerGroup.getHeaderGroupProps()}>
-              {headerGroup.headers.map(column => (
-                <th {...column.getHeaderProps()}>{column.render('Header')}</th>
-              ))}
-            </tr>
-          ))}
-        </thead>
-        <tbody {...getTableBodyProps()}>
-          {rows.map(
-            (row, i) =>
-              prepareRow(row) || (
-                <tr {...row.getRowProps()}>
-                  {row.cells.map(cell => {
-                    return (
-                      <td {...cell.getCellProps()}>{cell.render('Cell')}</td>
-                    )
-                  })}
-                </tr>
-              )
-          )}
-        </tbody>
-      </table>
-      <p>Selected Rows: {selectedRows.length}</p>
-      <pre>
-        <code>{JSON.stringify({ selectedRows }, null, 2)}</code>
-      </pre>
-    </>
-  )
-}
-
-function App() {
-  const columns = React.useMemo(
-    () => [
-      // Let's make a column for selection
-      {
-        id: 'selection',
-        // The header can use the table's getToggleAllRowsSelectedProps method
-        // to render a checkbox
-        Header: ({ getToggleAllRowsSelectedProps }) => (
-          <div>
-            <input type="checkbox" {...getToggleAllRowsSelectedProps()} />
-          </div>
-        ),
-        // The cell can use the individual row's getToggleRowSelectedProps method
-        // to the render a checkbox
-        Cell: ({ row }) => (
-          <div>
-            <input type="checkbox" {...row.getToggleRowSelectedProps()} />
-          </div>
-        ),
-      },
-      {
-        Header: 'Name',
-        columns: [
-          {
-            Header: 'First Name',
-            accessor: 'firstName',
-          },
-          {
-            Header: 'Last Name',
-            accessor: 'lastName',
-          },
-        ],
-      },
-      {
-        Header: 'Info',
-        columns: [
-          {
-            Header: 'Age',
-            accessor: 'age',
-          },
-          {
-            Header: 'Visits',
-            accessor: 'visits',
-          },
-          {
-            Header: 'Status',
-            accessor: 'status',
-          },
-          {
-            Header: 'Profile Progress',
-            accessor: 'progress',
-          },
-        ],
-      },
-    ],
-    []
-  )
-
-  const data = React.useMemo(() => makeData(10), [])
-
-  return <Table columns={columns} data={data} />
-}
-```
+- [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/row-selection)
+- [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/row-selection)
 
 # `useRowState`
 
@@ -1613,7 +888,7 @@ The following additional properties are available on every `Cell` object returne
 
 `useBlocklayout` is a plugin hook that adds support for headers and cells to be rendered as `inline-block` `div`s (or other non-table elements) with explicit `width`. Similar to the `useAbsoluteLayout` hook, this becomes useful if and when you need to virtualize rows and cells for performance.
 
-**NOTE:** Although no additional options are needed, the core column options `width`, `minWidth` and `maxWidth` are used to calculate column and cell widths and must be set. [See Column Options](#column-options) for more information on these options.
+**NOTE:** Although no additional options are needed for this plugin to work, the core column options `width`, `minWidth` and `maxWidth` are used to calculate column and cell widths and must be set. [See Column Options](#column-options) for more information on these options.
 
 ### Row Properties
 
@@ -1635,7 +910,7 @@ The following additional properties are available on every `Cell` object returne
 
 ### Example
 
-- [Source + Guide](https://github.com/tannerlinsley/react-table/tree/master/examples/block-layout)
+- [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/block-layout)
 - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/block-layout)
 
 # `useAbsoluteLayout`
@@ -1645,7 +920,7 @@ The following additional properties are available on every `Cell` object returne
 
 `useAbsoluteLayout` is a plugin hook that adds support for headers and cells to be rendered as absolutely positioned `div`s (or other non-table elements) with explicit `width`. Similar to the `useBlockLayout` hook, this becomes useful if and when you need to virtualize rows and cells for performance.
 
-**NOTE:** Although no additional options are needed, the core column options `width`, `minWidth` and `maxWidth` are used to calculate column and cell widths and must be set. [See Column Options](#column-options) for more information on these options.
+**NOTE:** Although no additional options are needed for this plugin to work, the core column options `width`, `minWidth` and `maxWidth` are used to calculate column and cell widths and must be set. [See Column Options](#column-options) for more information on these options.
 
 ### Instance Properties
 
@@ -1673,9 +948,45 @@ The following additional properties are available on every `Cell` object returne
 
 ### Example
 
-- [Source + Guide](https://github.com/tannerlinsley/react-table/tree/master/examples/absolute-layout)
+- [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/absolute-layout)
 - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/absolute-layout)
 
+# `useResizeColumns`
+
+- Plugin Hook
+- Optional
+
+`useResizeColumns` is a plugin hook that adds support for resizing headers and cells when using non-table elements for layout eg. the `useBlockLayout` and `useAbsoluteLayout` hooks. It even supports resizing column groups!
+
+### Table Options
+
+- `disableResizing: Bool`
+  - Defaults to `false`
+  - When set to `true`, resizing is disabled across the entire table
+
+### Column Options
+
+The core column options `width`, `minWidth` and `maxWidth` are used to calculate column and cell widths and must be set. [See Column Options](#column-options) for more information on these options.
+
+- `disableResizing: Bool`
+  - Defaults to `false`
+  - When set to `true`, resizing is disabled for this column
+
+### Header Properties
+
+- `getResizerProps`
+  - **Usage Required**
+  - This core prop getter is required to to enable absolute layout for headers
+- `canResize: Bool`
+  - Will be `true` if this column can be resized
+- `isResizing: Bool`
+  - Will be `true` if this column is currently being resized
+
+### Example
+
+- [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)
+
 # `useColumnOrder`
 
 - Plugin Hook
@@ -1697,9 +1008,13 @@ The following options are supported via the main options object passed to `useTa
 The following values are provided to the table `instance`:
 
 - `setColumnOrder: Function(updater: Function | Array<ColumnID>) => void`
+
   - Use this function to programmatically update the columnOrder.
   - `updater` can be a function or value. If a `function` is passed, it will receive the current value and expect a new one to be returned.
 
+- [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)
+
 # `useTableState`
 
 - Optional
@@ -1733,7 +1048,7 @@ The following options are supported via the main options object passed to `useTa
     - Optional
     - Inspired by Kent C. Dodd's [State Reducer Pattern](https://kentcdodds.com/blog/the-state-reducer-pattern-with-react-hooks)
     - With every `setState` call to a table state (even internally), this reducer is called and is allowed to modify the final state object for updating.
-    - It is passed the `oldState`, the `newState`, and an action `type`.
+    - It is passed the `oldState`, the `newState`, and an optional action `type`.
   - `useState`
     - Optional
     - Defaults to `React.useState`
@@ -1754,30 +1069,11 @@ The following options are supported via the main options object passed to `useTa
       - This function signature is **almost** (see next point) identical to the functional API exposed by `React.setState`. It is passed the previous state and is expected to return a new version of the state.
       - **NOTE: `updater` must be a function. Passing a replacement object is not supported as it is with React.useState**
     - `type: String`
+      - Optional
       - The [action type](TODO) corresponding to what action being taken against the state.
 
 ### Example
 
-```js
-export default function MyTable({ manualPageIndex }) {
-  // This is the initial state for our table
-  const initialState = { pageSize: 10, pageIndex: 0 }
-
-  // Here, we can override the pageIndex
-  // regardless of the internal table state
-  const overrides = React.useMemo(() => ({
-    pageIndex: manualPageIndex,
-  }))
-
-  const state = useTableState(initialState, overrides)
-
-  // You can use effects to observe changes to the state
-  React.useEffect(() => {
-    console.log('Page Size Changed!', initialState.pageSize)
-  }, [initialState.pageSize])
-
-  const { rows } = useTable({
-    state,
-  })
-}
-```
+- As used in Controlled Pagination
+  - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/pagination-controlled)
+  - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/pagination-controlled)

docs/examples.md

@@ -2,52 +2,55 @@
 
 - **Simple** - All of these examples use automatic state management, meaning, they don't hoist any state out of the table or manually control anything. Start here for understanding the basics about how to build your table UI.
   - Basic
-    - [Source + Guide](https://github.com/tannerlinsley/react-table/tree/master/examples/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)
   - Sorting
-    - [Source + Guide](https://github.com/tannerlinsley/react-table/tree/master/examples/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)
   - Filtering
-    - [Source + Guide](https://github.com/tannerlinsley/react-table/tree/master/examples/filtering)
+    - [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)
   - Grouping
-    - [Source + Guide](https://github.com/tannerlinsley/react-table/tree/master/examples/grouping)
+    - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/grouping)
     - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/grouping)
   - Pagination
-    - [Source + Guide](https://github.com/tannerlinsley/react-table/tree/master/examples/pagination)
+    - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/pagination)
     - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/pagination)
   - Row Selection
-    - [Source + Guide](https://github.com/tannerlinsley/react-table/tree/master/examples/row-selection)
+    - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/row-selection)
     - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/row-selection)
   - Expanding
-    - [Source + Guide](https://github.com/tannerlinsley/react-table/tree/master/examples/expanding)
+    - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/expanding)
     - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/expanding)
   - Sub Components
-    - [Source + Guide](https://github.com/tannerlinsley/react-table/tree/master/examples/sub-components)
+    - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/sub-components)
     - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/sub-components)
   - Editable Data
-    - [Source + Guide](https://github.com/tannerlinsley/react-table/tree/master/examples/editable-data)
+    - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/editable-data)
     - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/editable-data)
   - Column Ordering
-    - [Source + Guide](https://github.com/tannerlinsley/react-table/tree/master/examples/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 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)
 - **Complex**
   - The "Kitchen Sink"
-    - [Source + Guide](https://github.com/tannerlinsley/react-table/tree/master/examples/kitchen-sink)
+    - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/kitchen-sink)
     - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/kitchen-sink)
 - **Controlled via `useTableState`** - These examples are more advanced because they demonstrate how to manually control and respond to the state of the table using the `useTableState` hook.
   - Pagination (Controlled)
-    - [Source + Guide](https://github.com/tannerlinsley/react-table/tree/master/examples/pagination-controlled)
+    - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/pagination-controlled)
     - [Open in CodeSandobx](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/pagination-controlled)
 - **UI & Rendering** - These examples demonstrate how to use React Table with your favorite UI libraries or tools!
   - Virtualized Rows (React-Window)
-    - [Source + Guide](https://github.com/tannerlinsley/react-table/tree/master/examples/virtualized-rows)
+    - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/virtualized-rows)
     - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/virtualized-rows)
   - Animated (Framer-Motion)
-    - [Source + Guide](https://github.com/tannerlinsley/react-table/tree/master/examples/animated-framer-motion)
+    - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/animated-framer-motion)
     - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/animated-framer-motion)
   - Material-UI
-    - [Source + Guide](https://github.com/tannerlinsley/react-table/tree/master/examples/material-UI-components)
+    - [Source](https://github.com/tannerlinsley/react-table/tree/master/examples/material-UI-components)
     - [Open in CodeSandbox](https://codesandbox.io/s/github/tannerlinsley/react-table/tree/master/examples/material-UI-components)
   - [ ] Styled-Components
   - [ ] CSS

examples/column-resizing/.babelrc

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

examples/column-resizing/.env

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

examples/column-resizing/.eslintrc

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

examples/column-resizing/.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/column-resizing/.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/column-resizing/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/column-resizing)
+- `yarn` and `yarn start` to run and edit the example

examples/column-resizing/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": "next",
+    "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/column-resizing/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/column-resizing/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/column-resizing/src/App.js

@@ -0,0 +1,176 @@
+import React from 'react'
+import styled from 'styled-components'
+import { useTable, useBlockLayout, useResizeColumns } from 'react-table'
+
+import makeData from './makeData'
+
+const Styles = styled.div`
+  padding: 1rem;
+
+  .table {
+    display: inline-block;
+    border-spacing: 0;
+    border: 1px solid black;
+
+    .tr {
+      :last-child {
+        .td {
+          border-bottom: 0;
+        }
+      }
+    }
+
+    .th,
+    .td {
+      margin: 0;
+      padding: 0.5rem;
+      border-bottom: 1px solid black;
+      border-right: 1px solid black;
+
+      ${'' /* In this example we use an absolutely position resizer,
+       so this is required. */}
+      position: relative;
+
+      :last-child {
+        border-right: 0;
+      }
+
+      ${'' /* The resizer styles! */}
+
+      .resizer {
+        display: inline-block;
+        background: blue;
+        width: 5px;
+        height: 100%;
+        position: absolute;
+        right: 0;
+        top: 0;
+        transform: translateX(50%);
+        z-index: 1;
+
+        &.isResizing {
+          background: red;
+        }
+      }
+    }
+  }
+`
+
+function Table({ columns, data }) {
+  const defaultColumn = React.useMemo(
+    () => ({
+      minWidth: 20,
+      width: 150,
+      maxWidth: 500,
+    }),
+    []
+  )
+
+  const {
+    getTableProps,
+    getTableBodyProps,
+    headerGroups,
+    rows,
+    prepareRow,
+  } = useTable(
+    {
+      columns,
+      data,
+      defaultColumn,
+    },
+    useBlockLayout,
+    useResizeColumns
+  )
+
+  return (
+    <div {...getTableProps()} className="table">
+      <div>
+        {headerGroups.map(headerGroup => (
+          <div {...headerGroup.getHeaderGroupProps()} className="tr">
+            {headerGroup.headers.map(column => (
+              <div {...column.getHeaderProps()} className="th">
+                {column.render('Header')}
+                {/* Use column.getResizerProps to hook up the events correctly */}
+                <div
+                  {...column.getResizerProps()}
+                  className={`resizer ${column.isResizing ? 'isResizing' : ''}`}
+                />
+              </div>
+            ))}
+          </div>
+        ))}
+      </div>
+
+      <div {...getTableBodyProps()}>
+        {rows.map(
+          (row, i) =>
+            prepareRow(row) || (
+              <div {...row.getRowProps()} className="tr">
+                {row.cells.map(cell => {
+                  return (
+                    <div {...cell.getCellProps()} className="td">
+                      {cell.render('Cell')}
+                    </div>
+                  )
+                })}
+              </div>
+            )
+        )}
+      </div>
+    </div>
+  )
+}
+
+function App() {
+  const columns = React.useMemo(
+    () => [
+      {
+        Header: 'Name',
+        columns: [
+          {
+            Header: 'First Name',
+            accessor: 'firstName',
+          },
+          {
+            Header: 'Last Name',
+            accessor: 'lastName',
+          },
+        ],
+      },
+      {
+        Header: 'Info',
+        columns: [
+          {
+            Header: 'Age',
+            accessor: 'age',
+            width: 50,
+          },
+          {
+            Header: 'Visits',
+            accessor: 'visits',
+            width: 60,
+          },
+          {
+            Header: 'Status',
+            accessor: 'status',
+          },
+          {
+            Header: 'Profile Progress',
+            accessor: 'progress',
+          },
+        ],
+      },
+    ],
+    []
+  )
+
+  const data = React.useMemo(() => makeData(20), [])
+
+  return (
+    <Styles>
+      <Table columns={columns} data={data} />
+    </Styles>
+  )
+}
+
+export default App

examples/column-resizing/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/column-resizing/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/column-resizing/src/index.js

@@ -0,0 +1,12 @@
+import React from 'react'
+import ReactDOM from 'react-dom'
+import './index.css'
+import App from './App'
+import * as serviceWorker from './serviceWorker'
+
+ReactDOM.render(<App />, document.getElementById('root'))
+
+// If you want your app to work offline and load faster, you can change
+// unregister() to register() below. Note this comes with some pitfalls.
+// Learn more about service workers: https://bit.ly/CRA-PWA
+serviceWorker.unregister()

examples/column-resizing/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/column-resizing/src/serviceWorker.js

@@ -0,0 +1,135 @@
+// This optional code is used to register a service worker.
+// register() is not called by default.
+
+// This lets the app load faster on subsequent visits in production, and gives
+// it offline capabilities. However, it also means that developers (and users)
+// will only see deployed updates on subsequent visits to a page, after all the
+// existing tabs open on the page have been closed, since previously cached
+// resources are updated in the background.
+
+// To learn more about the benefits of this model and instructions on how to
+// opt-in, read https://bit.ly/CRA-PWA
+
+const isLocalhost = Boolean(
+  window.location.hostname === 'localhost' ||
+    // [::1] is the IPv6 localhost address.
+    window.location.hostname === '[::1]' ||
+    // 127.0.0.1/8 is considered localhost for IPv4.
+    window.location.hostname.match(
+      /^127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/
+    )
+)
+
+export function register(config) {
+  if (process.env.NODE_ENV === 'production' && 'serviceWorker' in navigator) {
+    // The URL constructor is available in all browsers that support SW.
+    const publicUrl = new URL(process.env.PUBLIC_URL, window.location.href)
+    if (publicUrl.origin !== window.location.origin) {
+      // Our service worker won't work if PUBLIC_URL is on a different origin
+      // from what our page is served on. This might happen if a CDN is used to
+      // serve assets; see https://github.com/facebook/create-react-app/issues/2374
+      return
+    }
+
+    window.addEventListener('load', () => {
+      const swUrl = `${process.env.PUBLIC_URL}/service-worker.js`
+
+      if (isLocalhost) {
+        // This is running on localhost. Let's check if a service worker still exists or not.
+        checkValidServiceWorker(swUrl, config)
+
+        // Add some additional logging to localhost, pointing developers to the
+        // service worker/PWA documentation.
+        navigator.serviceWorker.ready.then(() => {
+          console.log(
+            'This web app is being served cache-first by a service ' +
+              'worker. To learn more, visit https://bit.ly/CRA-PWA'
+          )
+        })
+      } else {
+        // Is not localhost. Just register service worker
+        registerValidSW(swUrl, config)
+      }
+    })
+  }
+}
+
+function registerValidSW(swUrl, config) {
+  navigator.serviceWorker
+    .register(swUrl)
+    .then(registration => {
+      registration.onupdatefound = () => {
+        const installingWorker = registration.installing
+        if (installingWorker == null) {
+          return
+        }
+        installingWorker.onstatechange = () => {
+          if (installingWorker.state === 'installed') {
+            if (navigator.serviceWorker.controller) {
+              // At this point, the updated precached content has been fetched,
+              // but the previous service worker will still serve the older
+              // content until all client tabs are closed.
+              console.log(
+                'New content is available and will be used when all ' +
+                  'tabs for this page are closed. See https://bit.ly/CRA-PWA.'
+              )
+
+              // Execute callback
+              if (config && config.onUpdate) {
+                config.onUpdate(registration)
+              }
+            } else {
+              // At this point, everything has been precached.
+              // It's the perfect time to display a
+              // "Content is cached for offline use." message.
+              console.log('Content is cached for offline use.')
+
+              // Execute callback
+              if (config && config.onSuccess) {
+                config.onSuccess(registration)
+              }
+            }
+          }
+        }
+      }
+    })
+    .catch(error => {
+      console.error('Error during service worker registration:', error)
+    })
+}
+
+function checkValidServiceWorker(swUrl, config) {
+  // Check if the service worker can be found. If it can't reload the page.
+  fetch(swUrl)
+    .then(response => {
+      // Ensure service worker exists, and that we really are getting a JS file.
+      const contentType = response.headers.get('content-type')
+      if (
+        response.status === 404 ||
+        (contentType != null && contentType.indexOf('javascript') === -1)
+      ) {
+        // No service worker found. Probably a different app. Reload the page.
+        navigator.serviceWorker.ready.then(registration => {
+          registration.unregister().then(() => {
+            window.location.reload()
+          })
+        })
+      } else {
+        // Service worker found. Proceed as normal.
+        registerValidSW(swUrl, config)
+      }
+    })
+    .catch(() => {
+      console.log(
+        'No internet connection found. App is running in offline mode.'
+      )
+    })
+}
+
+export function unregister() {
+  if ('serviceWorker' in navigator) {
+    navigator.serviceWorker.ready.then(registration => {
+      registration.unregister()
+    })
+  }
+}

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

@@ -285,7 +285,9 @@ function Table({ columns, data, updateMyData, disablePageResetOnDataChange }) {
     nextPage,
     previousPage,
     setPageSize,
-    state: [{ pageIndex, pageSize, groupBy, expanded, filters, selectedRows }],
+    state: [
+      { pageIndex, pageSize, groupBy, expanded, filters, selectedRowPaths },
+    ],
   } = useTable(
     {
       columns,
@@ -438,7 +440,7 @@ function Table({ columns, data, updateMyData, disablePageResetOnDataChange }) {
               groupBy,
               expanded,
               filters,
-              selectedRows,
+              selectedRowPaths,
             },
             null,
             2

examples/kitchen-sink/src/App.js

@@ -285,7 +285,9 @@ function Table({ columns, data, updateMyData, disablePageResetOnDataChange }) {
     nextPage,
     previousPage,
     setPageSize,
-    state: [{ pageIndex, pageSize, groupBy, expanded, filters, selectedRows }],
+    state: [
+      { pageIndex, pageSize, groupBy, expanded, filters, selectedRowPaths },
+    ],
   } = useTable(
     {
       columns,
@@ -438,7 +440,7 @@ function Table({ columns, data, updateMyData, disablePageResetOnDataChange }) {
               groupBy,
               expanded,
               filters,
-              selectedRows,
+              selectedRowPaths,
             },
             null,
             2

examples/row-selection/src/App.js

@@ -41,7 +41,8 @@ function Table({ columns, data }) {
     headerGroups,
     rows,
     prepareRow,
-    state: [{ selectedRows }],
+    selectedFlatRows,
+    state: [{ selectedRowPaths }],
   } = useTable(
     {
       columns,
@@ -78,9 +79,20 @@ function Table({ columns, data }) {
           )}
         </tbody>
       </table>
-      <p>Selected Rows: {selectedRows.length}</p>
+      <p>Selected Rows: {selectedRowPaths.length}</p>
       <pre>
-        <code>{JSON.stringify({ selectedRows }, null, 2)}</code>
+        <code>
+          {JSON.stringify(
+            {
+              selectedRowPaths,
+              'selectedFlatRows[].original': selectedFlatRows.map(
+                d => d.original
+              ),
+            },
+            null,
+            2
+          )}
+        </code>
       </pre>
     </>
   )

examples/virtualized-rows/sandbox.config.json

@@ -0,0 +1,5 @@
+{
+  "infiniteLoopProtection": false,
+  "hardReloadOnChange": false,
+  "view": "browser"
+}

examples/virtualized-rows/src/App.js

@@ -85,8 +85,6 @@ function Table({ columns, data }) {
     [prepareRow, rows]
   )
 
-  console.log(headerGroups)
-
   // Render the UI for your table
   return (
     <div {...getTableProps()} className="table">

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "react-table",
-  "version": "7.0.0-alpha.29",
+  "version": "7.0.0-beta.5",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
@@ -10033,16 +10033,17 @@
       "integrity": "sha512-BmJMHUWQcvjS2dQMwJ7dzvdbwpRChnq4AYk2sTU/4aySt9Kumk8y8W3HhTHss31wxzKb0AC/wsiX1AqDcOBIEA==",
       "dev": true
     },
-    "rollup-plugin-uglify": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/rollup-plugin-uglify/-/rollup-plugin-uglify-6.0.2.tgz",
-      "integrity": "sha512-qwz2Tryspn5QGtPUowq5oumKSxANKdrnfz7C0jm4lKxvRDsNe/hSGsB9FntUul7UeC4TsZEWKErVgE1qWSO0gw==",
+    "rollup-plugin-terser": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/rollup-plugin-terser/-/rollup-plugin-terser-5.1.2.tgz",
+      "integrity": "sha512-sWKBCOS+vUkRtHtEiJPAf+WnBqk/C402fBD9AVHxSIXMqjsY7MnYWKYEUqGixtr0c8+1DjzUEPlNgOYQPVrS1g==",
       "dev": true,
       "requires": {
         "@babel/code-frame": "^7.0.0",
-        "jest-worker": "^24.0.0",
-        "serialize-javascript": "^1.6.1",
-        "uglify-js": "^3.4.9"
+        "jest-worker": "^24.6.0",
+        "rollup-pluginutils": "^2.8.1",
+        "serialize-javascript": "^1.7.0",
+        "terser": "^4.1.0"
       }
     },
     "rollup-pluginutils": {
@@ -10781,6 +10782,25 @@
         }
       }
     },
+    "terser": {
+      "version": "4.3.4",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-4.3.4.tgz",
+      "integrity": "sha512-Kcrn3RiW8NtHBP0ssOAzwa2MsIRQ8lJWiBG/K7JgqPlomA3mtb2DEmp4/hrUA+Jujx+WZ02zqd7GYD+QRBB/2Q==",
+      "dev": true,
+      "requires": {
+        "commander": "^2.20.0",
+        "source-map": "~0.6.1",
+        "source-map-support": "~0.5.12"
+      },
+      "dependencies": {
+        "source-map": {
+          "version": "0.6.1",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+          "dev": true
+        }
+      }
+    },
     "test-exclude": {
       "version": "5.2.3",
       "resolved": "https://registry.npmjs.org/test-exclude/-/test-exclude-5.2.3.tgz",
@@ -11062,6 +11082,7 @@
       "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.6.0.tgz",
       "integrity": "sha512-W+jrUHJr3DXKhrsS7NUVxn3zqMOFn0hL/Ei6v0anCIMoKC93TjcflTagwIHLW7SfMFfiQuktQyFVCFHGUE0+yg==",
       "dev": true,
+      "optional": true,
       "requires": {
         "commander": "~2.20.0",
         "source-map": "~0.6.1"
@@ -11071,7 +11092,8 @@
           "version": "0.6.1",
           "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
           "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
-          "dev": true
+          "dev": true,
+          "optional": true
         }
       }
     },

package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-table",
-  "version": "7.0.0-beta.3",
+  "version": "7.0.0-beta.8",
   "description": "A fast, lightweight, opinionated table and datagrid built on React",
   "license": "MIT",
   "homepage": "https://github.com/tannerlinsley/react-table#readme",
@@ -17,6 +17,7 @@
   "main": "dist/index.js",
   "module": "dist/index.es.js",
   "jsnext:main": "dist/index.es.js",
+  "sideEffects": false,
   "scripts": {
     "commit": "git add . && git-cz",
     "test": "is-ci 'test:ci' 'test:dev'",
@@ -90,7 +91,7 @@
     "rollup-plugin-commonjs": "^9.1.3",
     "rollup-plugin-node-resolve": "^4.0.0",
     "rollup-plugin-peer-deps-external": "^2.2.0",
-    "rollup-plugin-uglify": "^6.0.2",
+    "rollup-plugin-terser": "^5.1.2",
     "snapshot-diff": "^0.5.2"
   },
   "config": {

rollup.config.js

@@ -2,7 +2,7 @@ import babel from 'rollup-plugin-babel'
 import commonjs from 'rollup-plugin-commonjs'
 import external from 'rollup-plugin-peer-deps-external'
 import resolve from 'rollup-plugin-node-resolve'
-import { uglify } from 'rollup-plugin-uglify'
+import { terser } from 'rollup-plugin-terser'
 
 import pkg from './package.json'
 
@@ -14,28 +14,15 @@ export default [
       format: 'cjs',
       sourcemap: true,
     },
-    plugins: [
-      external(),
-      babel({
-        exclude: 'node_modules/**',
-      }),
-      resolve(),
-      commonjs(),
-      uglify(),
-    ],
+    plugins: [external(), babel(), resolve(), commonjs(), terser()],
   },
   {
     input: 'src/index.js',
-    external: Object.keys(pkg.peerDependencies),
     output: {
       file: pkg.module,
       format: 'es',
       sourcemap: true,
     },
-    plugins: [
-      babel({
-        exclude: ['/**/node_modules/**'],
-      }),
-    ],
+    plugins: [external(), babel()],
   },
 ]

src/actions.js

@@ -5,11 +5,6 @@ export { actions, types }
 
 export const addActions = (...acts) => {
   acts.forEach(action => {
-    if (actions[action]) {
-      throw new Error(
-        `An React Table action type called ${action} has already been registered!`
-      )
-    }
     // Action values are formatted this way to discourage
     // you (the dev) from interacting with them in any way
     // other than importing `{ actions } from 'react-table'`

src/hooks/useTable.js

@@ -66,6 +66,7 @@ export const useTable = (props, ...plugins) => {
     hooks: {
       columnsBeforeHeaderGroups: [],
       columnsBeforeHeaderGroupsDeps: [],
+      useBeforeDimensions: [],
       useMain: [],
       useRows: [],
       prepareRow: [],
@@ -136,12 +137,11 @@ export const useTable = (props, ...plugins) => {
   })
 
   // Access the row model
-  const [rows, rowPaths, flatRows] = React.useMemo(() => {
+  const [rows, flatRows] = React.useMemo(() => {
     if (process.env.NODE_ENV === 'development' && debug)
       console.time('getAccessedRows')
 
-    let flatRows = 0
-    const rowPaths = []
+    let flatRows = []
 
     // Access the row's data
     const accessRow = (originalRow, i, depth = 0, parentPath = []) => {
@@ -153,23 +153,21 @@ export const useTable = (props, ...plugins) => {
       // Make the new path for the row
       const path = [...parentPath, rowID]
 
-      flatRows++
-      rowPaths.push(path.join('.'))
+      const row = {
+        original,
+        index: i,
+        path, // used to create a key for each row even if not nested
+        depth,
+        cells: [{}], // This is a dummy cell
+      }
+
+      flatRows.push(row)
 
       // Process any subRows
       let subRows = getSubRows(originalRow, i)
 
       if (subRows) {
-        subRows = subRows.map((d, i) => accessRow(d, i, depth + 1, path))
-      }
-
-      const row = {
-        original,
-        index: i,
-        path, // used to create a key for each row even if not nested
-        subRows,
-        depth,
-        cells: [{}], // This is a dummy cell
+        row.subRows = subRows.map((d, i) => accessRow(d, i, depth + 1, path))
       }
 
       // Override common array functions (and the dummy cell's getCellProps function)
@@ -199,11 +197,10 @@ export const useTable = (props, ...plugins) => {
     const accessedData = data.map((d, i) => accessRow(d, i))
     if (process.env.NODE_ENV === 'development' && debug)
       console.timeEnd('getAccessedRows')
-    return [accessedData, rowPaths, flatRows]
+    return [accessedData, flatRows]
   }, [debug, data, getRowID, getSubRows, flatColumns])
 
   instanceRef.current.rows = rows
-  instanceRef.current.rowPaths = rowPaths
   instanceRef.current.flatRows = flatRows
 
   // Determine column visibility
@@ -215,6 +212,15 @@ export const useTable = (props, ...plugins) => {
     []
   )
 
+  if (process.env.NODE_ENV === 'development' && debug)
+    console.time('hooks.useBeforeDimensions')
+  instanceRef.current = applyHooks(
+    instanceRef.current.hooks.useBeforeDimensions,
+    instanceRef.current
+  )
+  if (process.env.NODE_ENV === 'development' && debug)
+    console.timeEnd('hooks.useBeforeDimensions')
+
   calculateDimensions(instanceRef.current)
 
   if (process.env.NODE_ENV === 'development' && debug)

src/hooks/useTableState.js

@@ -1,7 +1,5 @@
 import React from 'react'
 //
-import { types } from '../actions'
-
 export const defaultState = {}
 
 const defaultReducer = (old, newState) => newState
@@ -33,14 +31,6 @@ export const useTableState = (
 
   const reducedSetState = React.useCallback(
     (updater, type) => {
-      if (!types[type]) {
-        console.info({
-          stateUpdaterFn: updater,
-          actionType: type,
-          currentState: overriddenStateRef.current,
-        })
-        throw new Error('Detected an unknown table action! (Details Above)')
-      }
       return setState(old => {
         const newState = updater(old)
         return reducer(old, newState, type)

src/index.js

@@ -11,6 +11,7 @@ export { usePagination } from './plugin-hooks/usePagination'
 export { useRowSelect } from './plugin-hooks/useRowSelect'
 export { useRowState } from './plugin-hooks/useRowState'
 export { useColumnOrder } from './plugin-hooks/useColumnOrder'
+export { useResizeColumns } from './plugin-hooks/useResizeColumns'
 export { useAbsoluteLayout } from './plugin-hooks/useAbsoluteLayout'
 export { useBlockLayout } from './plugin-hooks/useBlockLayout'
 export { actions, addActions } from './actions'

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

@@ -8,7 +8,7 @@ exports[`renders a table 1`] = `
     <div>
       <div
         class="row"
-        style="display: block; width: 1400px;"
+        style="display: flex; width: 1400px;"
       >
         <div
           class="cell header"
@@ -27,7 +27,7 @@ exports[`renders a table 1`] = `
       </div>
       <div
         class="row"
-        style="display: block; width: 1400px;"
+        style="display: flex; width: 1400px;"
       >
         <div
           class="cell header"
@@ -78,7 +78,7 @@ exports[`renders a table 1`] = `
     >
       <div
         class="row"
-        style="display: block; width: 1400px;"
+        style="display: flex; width: 1400px;"
       >
         <div
           class="cell"
@@ -119,7 +119,7 @@ exports[`renders a table 1`] = `
       </div>
       <div
         class="row"
-        style="display: block; width: 1400px;"
+        style="display: flex; width: 1400px;"
       >
         <div
           class="cell"
@@ -160,7 +160,7 @@ exports[`renders a table 1`] = `
       </div>
       <div
         class="row"
-        style="display: block; width: 1400px;"
+        style="display: flex; width: 1400px;"
       >
         <div
           class="cell"

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

@@ -485,8 +485,8 @@ Snapshot Diff:
     <pre>
       <code>
         {
--   "selectedRows": []
-+   "selectedRows": [
+-   "selectedRowPaths": []
++   "selectedRowPaths": [
 +     "0",
 +     "1",
 +     "2",
@@ -1015,7 +1015,7 @@ Snapshot Diff:
     <pre>
       <code>
         {
--   "selectedRows": [
+-   "selectedRowPaths": [
 -     "0",
 -     "1",
 -     "2",
@@ -1053,7 +1053,7 @@ Snapshot Diff:
 -     "22.1",
 -     "23"
 -   ]
-+   "selectedRows": []
++   "selectedRowPaths": []
   }
       </code>
     </pre>
@@ -1129,8 +1129,8 @@ Snapshot Diff:
     <pre>
       <code>
         {
--   "selectedRows": []
-+   "selectedRows": [
+-   "selectedRowPaths": []
++   "selectedRowPaths": [
 +     "0",
 +     "2",
 +     "2.0",
@@ -1198,7 +1198,7 @@ Snapshot Diff:
     <pre>
       <code>
         {
-    "selectedRows": [
+    "selectedRowPaths": [
 -     "0",
 -     "2",
 -     "2.0",
@@ -1241,7 +1241,7 @@ Snapshot Diff:
     <pre>
       <code>
         {
-    "selectedRows": [
+    "selectedRowPaths": [
 -     "0"
 +     "0",
 +     "2.0"
@@ -1282,7 +1282,7 @@ Snapshot Diff:
     <pre>
       <code>
         {
-    "selectedRows": [
+    "selectedRowPaths": [
       "0",
 -     "2.0"
 +     "2.0",
@@ -1324,7 +1324,7 @@ Snapshot Diff:
     <pre>
       <code>
         {
-    "selectedRows": [
+    "selectedRowPaths": [
       "0",
 -     "2.0",
 -     "2.1"

src/plugin-hooks/tests/useRowSelect.test.js

@@ -75,7 +75,7 @@ function Table({ columns, data }) {
     headerGroups,
     rows,
     prepareRow,
-    state: [{ selectedRows }],
+    state: [{ selectedRowPaths }],
   } = useTable(
     {
       columns,
@@ -113,9 +113,9 @@ function Table({ columns, data }) {
           )}
         </tbody>
       </table>
-      <p>Selected Rows: {selectedRows.length}</p>
+      <p>Selected Rows: {selectedRowPaths.length}</p>
       <pre>
-        <code>{JSON.stringify({ selectedRows }, null, 2)}</code>
+        <code>{JSON.stringify({ selectedRowPaths }, null, 2)}</code>
       </pre>
     </>
   )

src/plugin-hooks/useBlockLayout.js

@@ -18,7 +18,7 @@ const useMain = instance => {
 
   const rowStyles = {
     style: {
-      display: 'block',
+      display: 'flex',
       width: `${totalColumnsWidth}px`,
     },
   }

src/plugin-hooks/useExpanded.js

@@ -29,6 +29,7 @@ function useMain(instance) {
     rows,
     manualExpandedKey = 'expanded',
     paginateExpandedRows = true,
+    expandSubRows = true,
     hooks,
     state: [{ expanded }, setState],
   } = instance
@@ -82,11 +83,18 @@ function useMain(instance) {
       console.info('getExpandedRows')
 
     if (paginateExpandedRows) {
-      return expandRows(rows, { manualExpandedKey, expanded })
+      return expandRows(rows, { manualExpandedKey, expanded, expandSubRows })
     }
 
     return rows
-  }, [debug, paginateExpandedRows, rows, manualExpandedKey, expanded])
+  }, [
+    debug,
+    paginateExpandedRows,
+    rows,
+    manualExpandedKey,
+    expanded,
+    expandSubRows,
+  ])
 
   const expandedDepth = findExpandedDepth(expanded)
 

src/plugin-hooks/useFilters.js

@@ -33,6 +33,7 @@ function useMain(instance) {
   const {
     debug,
     rows,
+    flatRows,
     flatColumns,
     filterTypes: userFilterTypes,
     manualFilters,
@@ -41,6 +42,7 @@ function useMain(instance) {
   } = instance
 
   const preFilteredRows = rows
+  const preFilteredFlatRows = flatRows
 
   const setFilter = (id, updater) => {
     const column = flatColumns.find(d => d.id === id)
@@ -129,11 +131,16 @@ function useMain(instance) {
   // cache for each row group (top-level rows, and each row's recursive subrows)
   // This would make multi-filtering a lot faster though. Too far?
 
-  const filteredRows = React.useMemo(() => {
+  const { filteredRows, filteredFlatRows } = React.useMemo(() => {
     if (manualFilters || !Object.keys(filters).length) {
-      return rows
+      return {
+        filteredRows: rows,
+        filteredFlatRows: flatRows,
+      }
     }
 
+    const filteredFlatRows = []
+
     if (process.env.NODE_ENV === 'development' && debug)
       console.info('getFilteredRows')
 
@@ -179,6 +186,7 @@ function useMain(instance) {
       // but that would severely hinder the API for the user, since they
       // would be required to do that recursion in some scenarios
       filteredRows = filteredRows.map(row => {
+        filteredFlatRows.push(row)
         if (!row.subRows) {
           return row
         }
@@ -194,8 +202,19 @@ function useMain(instance) {
       return filteredRows
     }
 
-    return filterRows(rows)
-  }, [manualFilters, filters, debug, rows, flatColumns, userFilterTypes])
+    return {
+      filteredRows: filterRows(rows),
+      filteredFlatRows,
+    }
+  }, [
+    manualFilters,
+    filters,
+    debug,
+    rows,
+    flatRows,
+    flatColumns,
+    userFilterTypes,
+  ])
 
   React.useMemo(() => {
     // Now that each filtered column has it's partially filtered rows,
@@ -216,7 +235,9 @@ function useMain(instance) {
     setFilter,
     setAllFilters,
     preFilteredRows,
+    preFilteredFlatRows,
     rows: filteredRows,
+    flatRows: filteredFlatRows,
   }
 }
 

src/plugin-hooks/usePagination.js

@@ -36,6 +36,7 @@ function useMain(instance) {
     plugins,
     pageCount: userPageCount,
     paginateExpandedRows = true,
+    expandSubRows = true,
     state: [
       { pageSize, pageIndex, filters, groupBy, sortBy, expanded },
       setState,
@@ -101,9 +102,10 @@ function useMain(instance) {
       return page
     }
 
-    return expandRows(page, { manualExpandedKey, expanded })
+    return expandRows(page, { manualExpandedKey, expanded, expandSubRows })
   }, [
     debug,
+    expandSubRows,
     expanded,
     manualExpandedKey,
     manualPagination,

src/plugin-hooks/useResizeColumns.js

@@ -0,0 +1,142 @@
+import PropTypes from 'prop-types'
+
+//
+
+import { defaultState } from '../hooks/useTableState'
+import { defaultColumn, getFirstDefined } from '../utils'
+import { mergeProps, applyPropHooks } from '../utils'
+
+defaultState.columnResizing = {
+  columnWidths: {},
+}
+
+defaultColumn.canResize = true
+
+const propTypes = {}
+
+export const useResizeColumns = hooks => {
+  hooks.useBeforeDimensions.push(useBeforeDimensions)
+}
+
+useResizeColumns.pluginName = 'useResizeColumns'
+
+const useBeforeDimensions = instance => {
+  PropTypes.checkPropTypes(propTypes, instance, 'property', 'useResizeColumns')
+
+  instance.hooks.getResizerProps = []
+
+  const {
+    flatHeaders,
+    disableResizing,
+    hooks: { getHeaderProps },
+    state: [{ columnResizing }, setState],
+  } = instance
+
+  getHeaderProps.push(() => {
+    return {
+      style: {
+        position: 'relative',
+      },
+    }
+  })
+
+  const onMouseDown = (e, header) => {
+    const headersToResize = getLeafHeaders(header)
+    const startWidths = headersToResize.map(header => header.totalWidth)
+    const startX = e.clientX
+
+    const onMouseMove = e => {
+      const currentX = e.clientX
+      const deltaX = currentX - startX
+
+      const percentageDeltaX = deltaX / headersToResize.length
+
+      const newColumnWidths = {}
+      headersToResize.forEach((header, index) => {
+        newColumnWidths[header.id] = Math.max(
+          startWidths[index] + percentageDeltaX,
+          0
+        )
+      })
+
+      setState(old => ({
+        ...old,
+        columnResizing: {
+          ...old.columnResizing,
+          columnWidths: {
+            ...old.columnResizing.columnWidths,
+            ...newColumnWidths,
+          },
+        },
+      }))
+    }
+
+    const onMouseUp = e => {
+      document.removeEventListener('mousemove', onMouseMove)
+      document.removeEventListener('mouseup', onMouseUp)
+
+      setState(old => ({
+        ...old,
+        columnResizing: {
+          ...old.columnResizing,
+          startX: null,
+          isResizingColumn: null,
+        },
+      }))
+    }
+
+    document.addEventListener('mousemove', onMouseMove)
+    document.addEventListener('mouseup', onMouseUp)
+
+    setState(old => ({
+      ...old,
+      columnResizing: {
+        ...old.columnResizing,
+        startX,
+        isResizingColumn: header.id,
+      },
+    }))
+  }
+
+  flatHeaders.forEach(header => {
+    const canResize = getFirstDefined(
+      header.disableResizing === true ? false : undefined,
+      disableResizing === true ? false : undefined,
+      true
+    )
+
+    header.canResize = canResize
+    header.width = columnResizing.columnWidths[header.id] || header.width
+    header.isResizing = columnResizing.isResizingColumn === header.id
+
+    if (canResize) {
+      header.getResizerProps = userProps => {
+        return mergeProps(
+          {
+            onMouseDown: e => e.persist() || onMouseDown(e, header),
+            style: {
+              cursor: 'ew-resize',
+            },
+            draggable: false,
+          },
+          applyPropHooks(instance.hooks.getResizerProps, header, instance),
+          userProps
+        )
+      }
+    }
+  })
+
+  return instance
+}
+
+function getLeafHeaders(header) {
+  const leafHeaders = []
+  const recurseHeader = header => {
+    if (header.columns && header.columns.length) {
+      header.columns.map(recurseHeader)
+    }
+    leafHeaders.push(header)
+  }
+  recurseHeader(header)
+  return leafHeaders
+}

src/plugin-hooks/useRowSelect.js

@@ -1,10 +1,11 @@
+import React from 'react'
 import PropTypes from 'prop-types'
 
 import { mergeProps, applyPropHooks, ensurePluginOrder } from '../utils'
 import { addActions, actions } from '../actions'
 import { defaultState } from '../hooks/useTableState'
 
-defaultState.selectedRows = []
+defaultState.selectedRowPaths = []
 
 addActions('toggleRowSelected', 'toggleRowSelectedAll')
 
@@ -15,11 +16,41 @@ const propTypes = {
 export const useRowSelect = hooks => {
   hooks.getToggleRowSelectedProps = []
   hooks.getToggleAllRowsSelectedProps = []
+  hooks.useRows.push(useRows)
   hooks.useMain.push(useMain)
 }
 
 useRowSelect.pluginName = 'useRowSelect'
 
+function useRows(rows, instance) {
+  PropTypes.checkPropTypes(propTypes, instance, 'property', 'useRowSelect')
+
+  const {
+    state: [{ selectedRowPaths }],
+  } = instance
+
+  instance.selectedFlatRows = React.useMemo(() => {
+    const selectedFlatRows = []
+    rows.forEach(row => {
+      if (row.isAggregated) {
+        const subRowPaths = row.subRows.map(row => row.path)
+        row.isSelected = subRowPaths.every(path =>
+          selectedRowPaths.includes(path.join('.'))
+        )
+      } else {
+        row.isSelected = selectedRowPaths.includes(row.path.join('.'))
+      }
+      if (row.isSelected) {
+        selectedFlatRows.push(row)
+      }
+    })
+
+    return selectedFlatRows
+  }, [rows, selectedRowPaths])
+
+  return rows
+}
+
 function useMain(instance) {
   PropTypes.checkPropTypes(propTypes, instance, 'property', 'useRowSelect')
 
@@ -27,8 +58,8 @@ function useMain(instance) {
     hooks,
     manualRowSelectedKey = 'isSelected',
     plugins,
-    rowPaths,
-    state: [{ selectedRows }, setState],
+    flatRows,
+    state: [{ selectedRowPaths }, setState],
   } = instance
 
   ensurePluginOrder(
@@ -38,34 +69,44 @@ function useMain(instance) {
     []
   )
 
-  const isAllRowsSelected = rowPaths.length > 0 && rowPaths.length === selectedRows.length
+  const flatRowPaths = flatRows.map(d => d.path.join('.'))
+
+  let isAllRowsSelected = !!flatRowPaths.length && !!selectedRowPaths.length
+
+  if (isAllRowsSelected) {
+    if (flatRowPaths.some(d => !selectedRowPaths.includes(d))) {
+      isAllRowsSelected = false
+    }
+  }
 
   const toggleRowSelectedAll = set => {
     setState(old => {
       const selectAll = typeof set !== 'undefined' ? set : !isAllRowsSelected
       return {
         ...old,
-        selectedRows: selectAll ? [...rowPaths] : [],
+        selectedRowPaths: selectAll ? flatRowPaths : [],
       }
     }, actions.toggleRowSelectedAll)
   }
 
-  const updateParentRow = (selectedRows, path) => {
+  const updateParentRow = (selectedRowPaths, path) => {
     const parentPath = path.slice(0, path.length - 1)
     const parentKey = parentPath.join('.')
     const selected =
-      rowPaths.filter(
-        path =>
+      flatRowPaths.filter(rowPath => {
+        const path = rowPath
+        return (
           path !== parentKey &&
           path.startsWith(parentKey) &&
-          !selectedRows.has(path)
-      ).length === 0
+          !selectedRowPaths.has(path)
+        )
+      }).length === 0
     if (selected) {
-      selectedRows.add(parentKey)
+      selectedRowPaths.add(parentKey)
     } else {
-      selectedRows.delete(parentKey)
+      selectedRowPaths.delete(parentKey)
     }
-    if (parentPath.length > 1) updateParentRow(selectedRows, parentPath)
+    if (parentPath.length > 1) updateParentRow(selectedRowPaths, parentPath)
   }
 
   const toggleRowSelected = (path, set) => {
@@ -76,18 +117,18 @@ function useMain(instance) {
       // Join the paths of deep rows
       // to make a key, then manage all of the keys
       // in a flat object
-      const exists = old.selectedRows.includes(key)
+      const exists = old.selectedRowPaths.includes(key)
       const shouldExist = typeof set !== 'undefined' ? set : !exists
-      let newSelectedRows = new Set(old.selectedRows)
+      let newSelectedRows = new Set(old.selectedRowPaths)
 
       if (!exists && shouldExist) {
-        rowPaths.forEach(rowPath => {
+        flatRowPaths.forEach(rowPath => {
           if (rowPath === key || rowPath.startsWith(childRowPrefixKey)) {
             newSelectedRows.add(rowPath)
           }
         })
       } else if (exists && !shouldExist) {
-        rowPaths.forEach(rowPath => {
+        flatRowPaths.forEach(rowPath => {
           if (rowPath === key || rowPath.startsWith(childRowPrefixKey)) {
             newSelectedRows.delete(rowPath)
           }
@@ -102,7 +143,7 @@ function useMain(instance) {
 
       return {
         ...old,
-        selectedRows: [...newSelectedRows.values()],
+        selectedRowPaths: [...newSelectedRows.values()],
       }
     }, actions.toggleRowSelected)
   }
@@ -128,9 +169,6 @@ function useMain(instance) {
     // Aggregate rows have entirely different select logic
     if (row.isAggregated) {
       const subRowPaths = row.subRows.map(row => row.path)
-      row.isSelected = subRowPaths.every(path =>
-        selectedRows.includes(path.join('.'))
-      )
       row.toggleRowSelected = set => {
         set = typeof set !== 'undefined' ? set : !row.isSelected
         subRowPaths.forEach(path => {
@@ -166,7 +204,6 @@ function useMain(instance) {
         )
       }
     } else {
-      row.isSelected = selectedRows.includes(row.path.join('.'))
       row.toggleRowSelected = set => toggleRowSelected(row.path, set)
       row.getToggleRowSelectedProps = props => {
         let checked = false

src/utils.js

@@ -402,7 +402,10 @@ This usually means you need to need to name your plugin hook by setting the 'plu
   })
 }
 
-export function expandRows(rows, { manualExpandedKey, expanded }) {
+export function expandRows(
+  rows,
+  { manualExpandedKey, expanded, expandSubRows = true }
+) {
   const expandedRows = []
 
   const handleRow = row => {
@@ -416,7 +419,7 @@ export function expandRows(rows, { manualExpandedKey, expanded }) {
 
     expandedRows.push(row)
 
-    if (row.subRows && row.subRows.length && row.isExpanded) {
+    if (expandSubRows && row.subRows && row.subRows.length && row.isExpanded) {
       row.subRows.forEach(handleRow)
     }
   }

yarn.lock

@@ -6878,15 +6878,16 @@ rollup-plugin-peer-deps-external@^2.2.0:
   resolved "https://registry.yarnpkg.com/rollup-plugin-peer-deps-external/-/rollup-plugin-peer-deps-external-2.2.0.tgz#99ef9231aa01736f3e9605b7c3084a0d627f665b"
   integrity sha512-BmJMHUWQcvjS2dQMwJ7dzvdbwpRChnq4AYk2sTU/4aySt9Kumk8y8W3HhTHss31wxzKb0AC/wsiX1AqDcOBIEA==
 
-rollup-plugin-uglify@^6.0.2:
-  version "6.0.2"
-  resolved "https://registry.yarnpkg.com/rollup-plugin-uglify/-/rollup-plugin-uglify-6.0.2.tgz#681042cfdf7ea4e514971946344e1a95bc2772fe"
-  integrity sha512-qwz2Tryspn5QGtPUowq5oumKSxANKdrnfz7C0jm4lKxvRDsNe/hSGsB9FntUul7UeC4TsZEWKErVgE1qWSO0gw==
+rollup-plugin-terser@^5.1.2:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/rollup-plugin-terser/-/rollup-plugin-terser-5.1.2.tgz#3e41256205cb75f196fc70d4634227d1002c255c"
+  integrity sha512-sWKBCOS+vUkRtHtEiJPAf+WnBqk/C402fBD9AVHxSIXMqjsY7MnYWKYEUqGixtr0c8+1DjzUEPlNgOYQPVrS1g==
   dependencies:
     "@babel/code-frame" "^7.0.0"
-    jest-worker "^24.0.0"
-    serialize-javascript "^1.6.1"
-    uglify-js "^3.4.9"
+    jest-worker "^24.6.0"
+    rollup-pluginutils "^2.8.1"
+    serialize-javascript "^1.7.0"
+    terser "^4.1.0"
 
 rollup-pluginutils@^2.6.0, rollup-pluginutils@^2.8.1:
   version "2.8.1"
@@ -7014,10 +7015,10 @@ semver@^6.0.0, semver@^6.1.1:
   resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d"
   integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==
 
-serialize-javascript@^1.6.1:
-  version "1.7.0"
-  resolved "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-1.7.0.tgz#d6e0dfb2a3832a8c94468e6eb1db97e55a192a65"
-  integrity sha512-ke8UG8ulpFOxO8f8gRYabHQe/ZntKlcig2Mp+8+URDP1D8vJZ0KUt7LYo07q25Z/+JVSgpr/cui9PIp5H6/+nA==
+serialize-javascript@^1.7.0:
+  version "1.9.1"
+  resolved "https://registry.yarnpkg.com/serialize-javascript/-/serialize-javascript-1.9.1.tgz#cfc200aef77b600c47da9bb8149c943e798c2fdb"
+  integrity sha512-0Vb/54WJ6k5v8sSWN09S0ora+Hnr+cX40r9F170nT+mSkaxltoE/7R3OrIdBSUv1OoiobH1QoWQbCnAO+e8J1A==
 
 set-blocking@^2.0.0, set-blocking@~2.0.0:
   version "2.0.0"
@@ -7187,6 +7188,14 @@ source-map-support@^0.5.6:
     buffer-from "^1.0.0"
     source-map "^0.6.0"
 
+source-map-support@~0.5.12:
+  version "0.5.13"
+  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.13.tgz#31b24a9c2e73c2de85066c0feb7d44767ed52932"
+  integrity sha512-SHSKFHadjVA5oR4PPqhtAVdcBWwRYVd6g6cAXnIbRiIwc2EhPrTuKUBdSLvlEKyIP3GCf89fltvcZiP9MMFA1w==
+  dependencies:
+    buffer-from "^1.0.0"
+    source-map "^0.6.0"
+
 source-map-url@^0.4.0:
   version "0.4.0"
   resolved "https://registry.yarnpkg.com/source-map-url/-/source-map-url-0.4.0.tgz#3e935d7ddd73631b97659956d55128e87b5084a3"
@@ -7503,6 +7512,15 @@ tar@^4:
     safe-buffer "^5.1.2"
     yallist "^3.0.3"
 
+terser@^4.1.0:
+  version "4.3.4"
+  resolved "https://registry.yarnpkg.com/terser/-/terser-4.3.4.tgz#ad91bade95619e3434685d69efa621a5af5f877d"
+  integrity sha512-Kcrn3RiW8NtHBP0ssOAzwa2MsIRQ8lJWiBG/K7JgqPlomA3mtb2DEmp4/hrUA+Jujx+WZ02zqd7GYD+QRBB/2Q==
+  dependencies:
+    commander "^2.20.0"
+    source-map "~0.6.1"
+    source-map-support "~0.5.12"
+
 test-exclude@^4.2.1:
   version "4.2.3"
   resolved "https://registry.yarnpkg.com/test-exclude/-/test-exclude-4.2.3.tgz#a9a5e64474e4398339245a0a769ad7c2f4a97c20"
@@ -7678,7 +7696,7 @@ typedarray@^0.0.6:
   resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777"
   integrity sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=
 
-uglify-js@^3.1.4, uglify-js@^3.4.9:
+uglify-js@^3.1.4:
   version "3.6.0"
   resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.6.0.tgz#704681345c53a8b2079fb6cec294b05ead242ff5"
   integrity sha512-W+jrUHJr3DXKhrsS7NUVxn3zqMOFn0hL/Ei6v0anCIMoKC93TjcflTagwIHLW7SfMFfiQuktQyFVCFHGUE0+yg==