@patternfly/react-table 4.44.11 → 4.44.15

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>
+  );
+};

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

@@ -0,0 +1,54 @@
+import React from 'react';
+import { Table, TableHeader, TableBody, headerCol, TableProps } from '@patternfly/react-table';
+
+interface Repository {
+  name: string;
+  branches: string;
+  prs: string;
+  workspaces: string;
+  lastCommit: string;
+}
+
+export const LegacyTableSelectableRadio: 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' }
+  ];
+
+  const isRepoSelectable = (repo: Repository) => repo.name !== 'a'; // Arbitrary logic for this example
+
+  // 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 [selectedRepoName, setSelectedRepoName] = React.useState<string | null>(null);
+
+  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: selectedRepoName === repo.name,
+    disableSelection: !isRepoSelectable(repo)
+  }));
+
+  return (
+    <Table
+      onSelect={(_event, _isSelecting, rowIndex) => {
+        const repo = repositories[rowIndex];
+        setSelectedRepoName(repo.name);
+      }}
+      selectVariant="radio"
+      aria-label="Selectable Table with Radio Buttons"
+      cells={columns}
+      rows={rows}
+    >
+      <TableHeader />
+      <TableBody />
+    </Table>
+  );
+};

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

@@ -0,0 +1,120 @@
+import React from 'react';
+import {
+  TableProps,
+  sortable,
+  info,
+  cellWidth,
+  wrappable,
+  Table,
+  TableBody,
+  TableHeader
+} from '@patternfly/react-table';
+
+interface Repository {
+  name: string;
+  branches: string;
+  prs: string;
+  workspaces: string;
+  lastCommit: string;
+}
+
+export const LegacyTableSortable: 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);
+
+  // Since OnSort specifies sorted columns by index, we need sortable values for our object by column index.
+  // This example is trivial since our data objects just contain strings, but if the data was more complex
+  // this would be a place to return simplified string or number versions of each column to sort by.
+  const getSortableRowValues = (repo: Repository): (string | number)[] => {
+    const { name, branches, prs, workspaces, lastCommit } = repo;
+    return [name, branches, prs, workspaces, lastCommit];
+  };
+
+  // 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') {
+        // 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 columns: TableProps['cells'] = [
+    { title: 'Repositories', transforms: [sortable] },
+    {
+      title: 'Branches',
+      transforms: [
+        info({
+          tooltip: 'More information about branches'
+        }),
+        sortable
+      ]
+    },
+    { title: 'Pull requests', transforms: [sortable] },
+    {
+      title: 'Workspaces - Also this long header will wrap since we have applied the wrappable transform',
+      transforms: [sortable, wrappable, cellWidth(20)]
+    },
+    {
+      title: 'Last commit',
+      transforms: [
+        info({
+          tooltip: 'More information about commits'
+        })
+      ]
+    }
+  ];
+  const rows: TableProps['rows'] = sortedRepositories.map(repo => [
+    repo.name,
+    repo.branches,
+    repo.prs,
+    repo.workspaces,
+    repo.lastCommit
+  ]);
+
+  return (
+    <Table
+      aria-label="Sortable Table"
+      sortBy={{
+        index: activeSortIndex,
+        direction: activeSortDirection,
+        defaultDirection: 'asc' // starting sort direction when first sorting a column. Defaults to 'asc'
+      }}
+      onSort={(_event, index, direction) => {
+        setActiveSortIndex(index);
+        setActiveSortDirection(direction);
+      }}
+      cells={columns}
+      rows={rows}
+    >
+      <TableHeader />
+      <TableBody />
+    </Table>
+  );
+};