@patternfly/react-table 4.44.12 → 4.44.16

package/src/components/Table/examples/LegacyTableEmptyState.tsx

@@ -0,0 +1,48 @@
+import React from 'react';
+import { Table, TableHeader, TableBody, TableProps } from '@patternfly/react-table';
+import {
+  Bullseye,
+  EmptyState,
+  EmptyStateVariant,
+  EmptyStateIcon,
+  Title,
+  EmptyStateBody,
+  Button
+} from '@patternfly/react-core';
+import SearchIcon from '@patternfly/react-icons/dist/esm/icons/search-icon';
+
+// This example has been simplified to focus on the empty state. In real usage,
+// you may want to derive your rows from typed underlying data and minimal state. See other examples.
+
+export const LegacyTableEmptyState: React.FunctionComponent = () => {
+  const columns: TableProps['cells'] = ['Repositories', 'Branches', 'Pull requests', 'Workspaces', 'Last commit'];
+  const rows: TableProps['rows'] = [
+    {
+      heightAuto: true,
+      cells: [
+        {
+          props: { colSpan: 8 },
+          title: (
+            <Bullseye>
+              <EmptyState variant={EmptyStateVariant.small}>
+                <EmptyStateIcon icon={SearchIcon} />
+                <Title headingLevel="h2" size="lg">
+                  No results found
+                </Title>
+                <EmptyStateBody>Clear all filters and try again.</EmptyStateBody>
+                <Button variant="link">Clear all filters</Button>
+              </EmptyState>
+            </Bullseye>
+          )
+        }
+      ]
+    }
+  ];
+
+  return (
+    <Table aria-label="Table text with modifiers" cells={columns} rows={rows}>
+      <TableHeader />
+      <TableBody />
+    </Table>
+  );
+};

package/src/components/Table/examples/LegacyTableExpandable.tsx

@@ -0,0 +1,172 @@
+import React from 'react';
+import { Table, TableBody, TableHeader, TableVariant, TableProps, expandable, IRowCell } from '@patternfly/react-table';
+import { Checkbox } from '@patternfly/react-core';
+
+interface Repository {
+  name: string;
+  branches: string;
+  prs: string;
+  workspaces: string;
+  details?: {
+    detail1?: string;
+    detail2?: string;
+    detail3?: string;
+    detailFormat: 0 | 1 | 2 | 3;
+  };
+}
+
+export const LegacyTableExpandable: React.FunctionComponent = () => {
+  // In real usage, this data would come from some external source like an API via props.
+  const repositories: Repository[] = [
+    { name: 'one', branches: 'two', prs: 'a', workspaces: 'four' },
+    {
+      name: 'parent 1',
+      branches: 'two',
+      prs: 'k',
+      workspaces: 'four',
+      // This `details` structure is just for this example. You can drive expanded content from any kind of data.
+      details: { detailFormat: 0, detail1: 'single cell' }
+    },
+    {
+      name: 'parent 2',
+      branches: 'two',
+      prs: 'b',
+      workspaces: 'four',
+      details: { detailFormat: 1, detail1: 'single cell - fullWidth' }
+    },
+    {
+      name: 'parent 3',
+      branches: '2',
+      prs: 'b',
+      workspaces: 'four',
+      details: { detailFormat: 2, detail1: 'single cell - noPadding' }
+    },
+    {
+      name: 'parent 4',
+      branches: '2',
+      prs: 'b',
+      workspaces: 'four',
+      details: { detailFormat: 3, detail1: 'single cell - fullWidth & noPadding' }
+    },
+    {
+      name: 'parent 5',
+      branches: '2',
+      prs: 'b',
+      workspaces: 'four',
+      details: {
+        detailFormat: 0,
+        detail1: "spans 'Repositories and 'Branches'",
+        detail2: "spans 'Pull requests' and 'Workspaces', and 'Last commit'"
+      }
+    },
+    {
+      name: 'parent 6',
+      branches: '2',
+      prs: 'b',
+      workspaces: 'four',
+      details: {
+        detailFormat: 1,
+        detail1: "fullWidth, spans the collapsible column and 'Repositories'",
+        detail2: "fullWidth, spans 'Branches' and 'Pull requests'",
+        detail3: 'fullWidth, spans the empty column'
+      }
+    }
+  ];
+
+  // In this example, expanded rows are tracked by the repo names from each row. This could be any unique identifier.
+  // This is to prevent state from being based on row order index in case we later add sorting.
+  // Note that this behavior is very similar to selection state.
+  const initialExpandedRepoNames = repositories.filter(repo => !!repo.details).map(repo => repo.name); // Default to all expanded
+  const [expandedRepoNames, setExpandedRepoNames] = React.useState<string[]>(initialExpandedRepoNames);
+  const setRepoExpanded = (repo: Repository, isExpanding = true) =>
+    setExpandedRepoNames(prevExpanded => {
+      const otherExpandedRepoNames = prevExpanded.filter(r => r !== repo.name);
+      return isExpanding ? [...otherExpandedRepoNames, repo.name] : otherExpandedRepoNames;
+    });
+  const isRepoExpanded = (repo: Repository) => expandedRepoNames.includes(repo.name);
+
+  const [isExampleCompact, setIsExampleCompact] = React.useState(true);
+
+  // We want to be able to reference the original data object based on row index. But because an expanded
+  // row takes up two row indexes, repositories[rowIndex] will not be accurate like it would in a normal table.
+  // One solution to this is to create an array of data objects indexed by the displayed row index.
+  const reposByRowIndex: (Repository | null)[] = [];
+
+  const columns: TableProps['cells'] = [
+    {
+      title: 'Repositories',
+      cellFormatters: [expandable]
+    },
+    'Branches',
+    { title: 'Pull requests' },
+    { title: '' /* deliberately empty */, dataLabel: 'Label for mobile view' }
+  ];
+  const rows: TableProps['rows'] = [];
+  repositories.forEach(repo => {
+    rows.push({
+      ...(repo.details ? { isOpen: isRepoExpanded(repo) } : {}),
+      cells: [repo.name, repo.branches, repo.prs, repo.workspaces]
+    });
+    reposByRowIndex.push(repo);
+    if (repo.details) {
+      // Some arbitrary examples of how you could customize the child row based on your needs
+      const { detail1, detail2, detail3, detailFormat } = repo.details;
+      const numColumns = 5;
+      const childIsFullWidth = [1, 3].includes(detailFormat);
+      const childHasNoPadding = [2, 3].includes(detailFormat);
+      let detailColSpans = [1, 1, 1];
+      if (detail1 && !detail2 && !detail3) {
+        detailColSpans = [childIsFullWidth ? numColumns : numColumns + 1]; // Account for toggle column
+      } else if (detail1 && detail2 && !detail3) {
+        detailColSpans = [2, childIsFullWidth ? 3 : 4];
+      } else if (detail1 && detail2 && detail3) {
+        detailColSpans = [2, 2, childIsFullWidth ? 1 : 2];
+      }
+      const cells: IRowCell[] = [];
+      [detail1, detail2, detail3].forEach((detail, index) => {
+        if (detail) {
+          cells.push({
+            title: detail1,
+            props: {
+              colSpan: detailColSpans[index]
+            }
+          });
+        }
+      });
+      rows.push({
+        parent: rows.length - 1,
+        cells,
+        fullWidth: childIsFullWidth,
+        noPadding: childHasNoPadding
+      });
+      reposByRowIndex.push(null);
+    }
+  });
+
+  return (
+    <React.Fragment>
+      <Checkbox
+        label="Compact"
+        isChecked={isExampleCompact}
+        onChange={checked => setIsExampleCompact(checked)}
+        aria-label="toggle compact variation"
+        id="toggle-compact"
+        name="toggle-compact"
+      />
+      <Table
+        aria-label="Expandable table"
+        variant={isExampleCompact ? TableVariant.compact : undefined}
+        onCollapse={(_event, rowIndex, isOpen) => {
+          if (reposByRowIndex[rowIndex]) {
+            setRepoExpanded(reposByRowIndex[rowIndex], isOpen);
+          }
+        }}
+        rows={rows}
+        cells={columns}
+      >
+        <TableHeader />
+        <TableBody />
+      </Table>
+    </React.Fragment>
+  );
+};

package/src/components/Table/examples/LegacyTableFavoritable.tsx

@@ -0,0 +1,157 @@
+import React from 'react';
+import { Table, TableHeader, TableBody, sortable, TableProps } from '@patternfly/react-table';
+import { Checkbox } from '@patternfly/react-core';
+
+interface Repository {
+  name: string;
+  branches: string;
+  prs: string;
+  workspaces: string;
+  lastCommit: string;
+}
+
+export const LegacyTableFavoritable: React.FunctionComponent = () => {
+  // In real usage, this data would come from some external source like an API via props.
+  const repositories: Repository[] = [
+    { name: 'one', branches: 'two', prs: 'a', workspaces: 'four', lastCommit: 'five' },
+    { name: 'a', branches: 'two', prs: 'k', workspaces: 'four', lastCommit: 'five' },
+    { name: 'p', branches: 'two', prs: 'b', workspaces: 'four', lastCommit: 'five' }
+  ];
+
+  // Index of the currently sorted column
+  // Note: if you intend to make columns reorderable, you may instead want to use a non-numeric key
+  // as the identifier of the sorted column. See the "Compound expandable" example.
+  const [activeSortIndex, setActiveSortIndex] = React.useState<number | null>(null);
+
+  // Sort direction of the currently sorted column
+  const [activeSortDirection, setActiveSortDirection] = React.useState<'asc' | 'desc' | null>(null);
+
+  // Favorite state is similar to selection state. See selectedRepoNames and associated code below.
+  const [favoriteRepoNames, setFavoriteRepoNames] = React.useState<string[]>([]);
+  const setRepoFavorited = (repo: Repository, isFavoriting = true) =>
+    setFavoriteRepoNames(prevFavorites => {
+      const otherFavorites = prevFavorites.filter(r => r !== repo.name);
+      return isFavoriting ? [...otherFavorites, repo.name] : otherFavorites;
+    });
+  const isRepoFavorited = (repo: Repository) => favoriteRepoNames.includes(repo.name);
+
+  // Since OnSort specifies sorted columns by index, we need sortable values for our object by column index.
+  // Note: We also memoize the sortable values with useCallback to prevent rows jumping around when you change
+  // the favorites while sorting on that column. Only updating the sort state will reorder the rows.
+  const getSortableRowValues = React.useCallback(
+    (repo: Repository): (boolean | string | number)[] => {
+      const { name, branches, prs, workspaces, lastCommit } = repo;
+      // Blank value for first column (select checkboxes)
+      return ['', isRepoFavorited(repo), name, branches, prs, workspaces, lastCommit];
+    },
+    [activeSortIndex, activeSortDirection]
+  );
+
+  // Note that we perform the sort as part of the component's render logic and not in onSort.
+  // We shouldn't store the list of data in state because we don't want to have to sync that with props.
+  let sortedRepositories = repositories;
+  if (activeSortIndex !== null) {
+    sortedRepositories = repositories.sort((a, b) => {
+      const aValue = getSortableRowValues(a)[activeSortIndex];
+      const bValue = getSortableRowValues(b)[activeSortIndex];
+      if (typeof aValue === 'number' || typeof aValue === 'boolean') {
+        // Numeric sort
+        if (activeSortDirection === 'asc') {
+          return (aValue as number) - (bValue as number);
+        }
+        return (bValue as number) - (aValue as number);
+      } else {
+        // String sort
+        if (activeSortDirection === 'asc') {
+          return (aValue as string).localeCompare(bValue as string);
+        }
+        return (bValue as string).localeCompare(aValue as string);
+      }
+    });
+  }
+
+  const isRepoSelectable = (repo: Repository) => repo.name !== 'a'; // Arbitrary logic for this example
+  const selectableRepos = repositories.filter(isRepoSelectable);
+
+  // In this example, selected rows are tracked by the repo names from each row. This could be any unique identifier.
+  // This is to prevent state from being based on row order index in case we later add sorting.
+  const [selectedRepoNames, setSelectedRepoNames] = React.useState<string[]>([]);
+  const setRepoSelected = (repo: Repository, isSelecting = true) =>
+    setSelectedRepoNames(prevSelected => {
+      const otherSelectedRepoNames = prevSelected.filter(r => r !== repo.name);
+      return isSelecting && isRepoSelectable(repo) ? [...otherSelectedRepoNames, repo.name] : otherSelectedRepoNames;
+    });
+  const selectAllRepos = (isSelecting = true) =>
+    setSelectedRepoNames(isSelecting ? selectableRepos.map(r => r.name) : []);
+  const isRepoSelected = (repo: Repository) => selectedRepoNames.includes(repo.name);
+
+  const columns: TableProps['cells'] = [
+    { title: 'Repositories', transforms: [sortable] },
+    'Branches',
+    'Pull requests',
+    'Workspaces',
+    'Last commit'
+  ];
+  const rows: TableProps['rows'] = sortedRepositories.map(repo => {
+    const favorited = isRepoFavorited(repo);
+    return {
+      favorited,
+      // The favorites button has defaults that can be overriden
+      favoritesProps: {
+        'aria-label': favorited ? 'Favorited' : 'Not favorited', // Defaults to 'Starred' / 'Not starred'
+        id: `favorites-button-${repo.name}`, // Defaults to `favorites-button-${rowIndex}`
+        'aria-labelledby': `favorites-button-${repo.name}` // Defaults to `favorites-button-${rowIndex}`
+      },
+      selected: isRepoSelected(repo),
+      disableSelection: !isRepoSelectable(repo),
+      cells: [repo.name, repo.branches, repo.prs, repo.workspaces, repo.lastCommit]
+    };
+  });
+
+  const [canSortFavorites, setCanSortFavorites] = React.useState(true);
+
+  return (
+    <div>
+      <Checkbox
+        label="Can sort favorites"
+        isChecked={canSortFavorites}
+        onChange={setCanSortFavorites}
+        aria-label="toggle can sort favorites checkbox"
+        id="toggle-can-sort-favorites"
+        name="toggle-can-sort-favorites"
+      />
+      <Table
+        // using this prop enables the favorites column
+        onFavorite={(_event, isFavoriting, rowIndex) => {
+          const repo = sortedRepositories[rowIndex];
+          setRepoFavorited(repo, isFavoriting);
+        }}
+        // if the onSort prop is detected, favorites can be sorted
+        // if you want to exclude favorites from sorting you can use this prop with a value of `false`
+        canSortFavorites={canSortFavorites}
+        onSelect={(_event, isSelecting, rowIndex) => {
+          if (rowIndex === -1) {
+            selectAllRepos(isSelecting);
+          } else {
+            const repo = sortedRepositories[rowIndex];
+            setRepoSelected(repo, isSelecting);
+          }
+        }}
+        onSort={(_event, index, direction) => {
+          setActiveSortIndex(index);
+          setActiveSortDirection(direction);
+        }}
+        sortBy={{
+          index: activeSortIndex,
+          direction: activeSortDirection
+        }}
+        aria-label="Favoritable Table"
+        cells={columns}
+        rows={rows}
+      >
+        <TableHeader />
+        <TableBody />
+      </Table>
+    </div>
+  );
+};

package/src/components/Table/examples/LegacyTableHoverable.tsx

@@ -0,0 +1,125 @@
+import React from 'react';
+import { Table, TableHeader, TableBody, info, textCenter, TableProps, ICell } from '@patternfly/react-table';
+import styles from '@patternfly/react-styles/css/components/Table/table';
+
+interface Repository {
+  name: string;
+  branches: string | null;
+  prs: string | null;
+  workspaces: string;
+  lastCommit: string;
+}
+
+export const LegacyTableHoverable: React.FunctionComponent = () => {
+  // In real usage, this data would come from some external source like an API via props.
+  const repositories: Repository[] = [
+    {
+      name: 'Repository one',
+      branches: 'Branch one',
+      prs: 'PR one',
+      workspaces: 'Workspace one',
+      lastCommit: 'Commit one'
+    },
+    { name: 'one - 2', branches: null, prs: null, workspaces: 'four - 2', lastCommit: 'five - 2' },
+    {
+      name: 'one - 3',
+      branches: 'two - 3',
+      prs: 'three - 3',
+      workspaces: 'four - 3',
+      lastCommit: 'five - 3 (not centered)'
+    }
+  ];
+
+  // In this example, selected rows are tracked by the repo names from each row. This could be any unique identifier.
+  // This is to prevent state from being based on row order index in case we later add sorting.
+  const [selectedRepoNames, setSelectedRepoNames] = React.useState<string[]>([]);
+  const setRepoSelected = (repo: Repository, isSelecting = true) =>
+    setSelectedRepoNames(prevSelected => {
+      const otherSelectedRepoNames = prevSelected.filter(r => r !== repo.name);
+      return isSelecting ? [...otherSelectedRepoNames, repo.name] : otherSelectedRepoNames;
+    });
+  const isRepoSelected = (repo: Repository) => selectedRepoNames.includes(repo.name);
+
+  const columns: TableProps['cells'] = [
+    {
+      title: 'Repositories',
+      transforms: [
+        info({
+          tooltip: 'More information about repositories',
+          className: 'repositories-info-tip',
+          tooltipProps: {
+            isContentLeftAligned: true
+          }
+        })
+      ]
+    },
+    'Branches',
+    {
+      title: 'Pull requests',
+      transforms: [
+        info({
+          popover: (
+            <div>
+              More <strong>information</strong> on pull requests
+            </div>
+          ),
+          ariaLabel: 'More information on pull requests',
+          popoverProps: {
+            headerContent: 'Pull requests',
+            footerContent: <a href="#">Click here for even more info</a>
+          }
+        })
+      ]
+    },
+    'Workspaces',
+    {
+      title: 'Last commit',
+      transforms: [textCenter],
+      cellTransforms: [textCenter]
+    }
+  ];
+  const rows: TableProps['rows'] = repositories.map(repo => {
+    let cells: (string | ICell)[] = [repo.name, repo.branches || '', repo.prs || '', repo.workspaces, repo.lastCommit];
+    // These rows have arbitrary differences for this example, but these could be based on some other conditions
+    if (repo.name === 'one - 2') {
+      cells = [
+        {
+          title: <div>{repo.name}</div>,
+          props: { title: 'hover title', colSpan: 3 }
+        },
+        repo.workspaces,
+        repo.lastCommit
+      ];
+    } else if (repo.name === 'five - 3 (not centrered)') {
+      cells = [
+        repo.name,
+        repo.branches || '',
+        repo.prs || '',
+        repo.workspaces,
+        {
+          title: repo.lastCommit,
+          props: { textCenter: false }
+        }
+      ];
+    }
+    return {
+      cells,
+      isHoverable: true,
+      isRowSelected: isRepoSelected(repo)
+    };
+  });
+
+  return (
+    <Table caption="Row click handler table" cells={columns} rows={rows}>
+      <TableHeader className={styles.modifiers.nowrap} />
+      <TableBody
+        onRowClick={(_event, row, rowProps) => {
+          if (rowProps) {
+            const repo = repositories[rowProps.rowIndex];
+            setRepoSelected(repo, !isRepoSelected(repo));
+          }
+        }}
+      />
+    </Table>
+  );
+};

package/src/components/Table/examples/LegacyTableMisc.tsx

@@ -0,0 +1,56 @@
+import React from 'react';
+import { Table, TableHeader, TableBody, TableProps } from '@patternfly/react-table';
+import { css } from '@patternfly/react-styles';
+
+interface Repository {
+  name: string;
+  branches: string | null;
+  prs: string | null;
+  workspaces: string;
+  lastCommit: string;
+}
+
+export const LegacyTableMisc: React.FunctionComponent = () => {
+  // In real usage, this data would come from some external source like an API via props.
+  const repositories: Repository[] = [
+    { name: 'one', branches: 'two', prs: 'three', workspaces: 'four', lastCommit: 'five' },
+    { name: 'one - 2', branches: null, prs: null, workspaces: 'four - 2', lastCommit: 'five - 2' },
+    { name: 'one - 3', branches: 'two - 3', prs: 'three - 3', workspaces: 'four - 3', lastCommit: 'five - 3' }
+  ];
+
+  const columns: TableProps['cells'] = ['Repositories', 'Branches', 'Pull requests', 'Workspaces', 'Last commit'];
+  const rows: TableProps['rows'] = repositories.map(repo => [
+    repo.name,
+    repo.branches || '',
+    repo.prs || '',
+    repo.workspaces,
+    repo.lastCommit
+  ]);
+
+  const customRowWrapper: TableProps['rowWrapper'] = ({ trRef, className, rowProps, row: _row, ...props }) => {
+    const isOddRow = rowProps ? !!((rowProps.rowIndex + 1) % 2) : true;
+    const customStyle = {
+      borderLeft: '3px solid var(--pf-global--primary-color--100)'
+    };
+    return (
+      <tr
+        {...props}
+        ref={trRef as React.LegacyRef<HTMLTableRowElement>}
+        className={css(className, isOddRow ? 'odd-row-class' : 'even-row-class', 'custom-static-class')}
+        style={isOddRow ? customStyle : {}}
+      />
+    );
+  };
+
+  return (
+    <Table
+      caption="Table with custom row wrapper that styles odd rows"
+      cells={columns}
+      rows={rows}
+      rowWrapper={customRowWrapper}
+    >
+      <TableHeader />
+      <TableBody />
+    </Table>
+  );
+};

package/src/components/Table/examples/LegacyTableSelectable.tsx

@@ -0,0 +1,124 @@
+import React from 'react';
+import { Table, TableBody, TableHeader, headerCol, TableProps } from '@patternfly/react-table';
+import { Checkbox } from '@patternfly/react-core';
+
+interface Repository {
+  name: string;
+  branches: string;
+  prs: string;
+  workspaces: string;
+  lastCommit: string;
+}
+
+export const LegacyTableSelectable: React.FunctionComponent = () => {
+  // In real usage, this data would come from some external source like an API via props.
+  const repositories: Repository[] = [
+    { name: 'one', branches: 'two', prs: 'a', workspaces: 'four', lastCommit: 'five' },
+    { name: 'a', branches: 'two', prs: 'k', workspaces: 'four', lastCommit: 'five' },
+    { name: 'b', branches: 'two', prs: 'k', workspaces: 'four', lastCommit: 'five' },
+    { name: 'c', branches: 'two', prs: 'k', workspaces: 'four', lastCommit: 'five' },
+    { name: 'd', branches: 'two', prs: 'k', workspaces: 'four', lastCommit: 'five' },
+    { name: 'e', branches: 'two', prs: 'b', workspaces: 'four', lastCommit: 'five' }
+  ];
+
+  const isRepoSelectable = (repo: Repository) => repo.name !== 'a'; // Arbitrary logic for this example
+  const selectableRepos = repositories.filter(isRepoSelectable);
+
+  // In this example, selected rows are tracked by the repo names from each row. This could be any unique identifier.
+  // This is to prevent state from being based on row order index in case we later add sorting.
+  const [selectedRepoNames, setSelectedRepoNames] = React.useState<string[]>([]);
+  const setRepoSelected = (repo: Repository, isSelecting = true) =>
+    setSelectedRepoNames(prevSelected => {
+      const otherSelectedRepoNames = prevSelected.filter(r => r !== repo.name);
+      return isSelecting && isRepoSelectable(repo) ? [...otherSelectedRepoNames, repo.name] : otherSelectedRepoNames;
+    });
+  const selectAllRepos = (isSelecting = true) =>
+    setSelectedRepoNames(isSelecting ? selectableRepos.map(r => r.name) : []);
+  const isRepoSelected = (repo: Repository) => selectedRepoNames.includes(repo.name);
+
+  const [canSelectAll, setCanSelectAll] = React.useState(true);
+
+  // To allow shift+click to select/deselect multiple rows
+  const [recentSelectedRowIndex, setRecentSelectedRowIndex] = React.useState<number | null>(null);
+  const [shifting, setShifting] = React.useState(false);
+
+  const onSelectRepo = (repo: Repository, rowIndex: number, isSelecting: boolean) => {
+    // If the user is shift + selecting the checkboxes, then all intermediate checkboxes should be selected
+    if (shifting && recentSelectedRowIndex !== null) {
+      const numberSelected = rowIndex - recentSelectedRowIndex;
+      const intermediateIndexes =
+        numberSelected > 0
+          ? Array.from(new Array(numberSelected + 1), (_x, i) => i + recentSelectedRowIndex)
+          : Array.from(new Array(Math.abs(numberSelected) + 1), (_x, i) => i + rowIndex);
+      intermediateIndexes.forEach(index => setRepoSelected(repositories[index], isSelecting));
+    } else {
+      setRepoSelected(repo, isSelecting);
+    }
+    setRecentSelectedRowIndex(rowIndex);
+  };
+
+  React.useEffect(() => {
+    const onKeyDown = (e: KeyboardEvent) => {
+      if (e.key === 'Shift') {
+        setShifting(true);
+      }
+    };
+    const onKeyUp = (e: KeyboardEvent) => {
+      if (e.key === 'Shift') {
+        setShifting(false);
+      }
+    };
+
+    document.addEventListener('keydown', onKeyDown);
+    document.addEventListener('keyup', onKeyUp);
+
+    return () => {
+      document.removeEventListener('keydown', onKeyDown);
+      document.removeEventListener('keyup', onKeyUp);
+    };
+  }, []);
+
+  const columns: TableProps['cells'] = [
+    { title: 'Repositories', cellTransforms: [headerCol()] },
+    'Branches',
+    { title: 'Pull requests' },
+    'Workspaces',
+    'Last commit'
+  ];
+  const rows: TableProps['rows'] = repositories.map(repo => ({
+    cells: [repo.name, repo.branches, repo.prs, repo.workspaces, repo.lastCommit],
+    selected: isRepoSelected(repo),
+    disableSelection: !isRepoSelectable(repo)
+  }));
+
+  return (
+    <div>
+      <Checkbox
+        label="Can select all"
+        className="pf-u-mb-lg"
+        isChecked={canSelectAll}
+        onChange={checked => setCanSelectAll(checked)}
+        aria-label="toggle select all checkbox"
+        id="toggle-select-all"
+        name="toggle-select-all"
+      />
+      <Table
+        onSelect={(_event, isSelecting, rowIndex) => {
+          if (rowIndex === -1) {
+            selectAllRepos(isSelecting);
+          } else {
+            const repo = repositories[rowIndex];
+            onSelectRepo(repo, rowIndex, isSelecting);
+          }
+        }}
+        canSelectAll={canSelectAll}
+        aria-label="Selectable Table"
+        cells={columns}
+        rows={rows}
+      >
+        <TableHeader />
+        <TableBody />
+      </Table>
+    </div>
+  );
+};