@patternfly/react-table 4.44.12 → 4.44.13

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

@@ -0,0 +1,175 @@
+import React from 'react';
+import { Table, TableHeader, TableBody, compoundExpand, TableProps } from '@patternfly/react-table';
+
+import CodeBranchIcon from '@patternfly/react-icons/dist/esm/icons/code-branch-icon';
+import CodeIcon from '@patternfly/react-icons/dist/esm/icons/code-icon';
+import CubeIcon from '@patternfly/react-icons/dist/esm/icons/cube-icon';
+
+interface Repository {
+  name: string;
+  branches: number;
+  prs: number;
+  workspaces: number;
+  lastCommit: string;
+}
+
+export const LegacyTableCompoundExpandable: React.FunctionComponent = () => {
+  // In real usage, this data would come from some external source like an API via props.
+  const repositories: Repository[] = [
+    { name: 'siemur/test-space', branches: 10, prs: 4, workspaces: 4, lastCommit: '20 minutes' },
+    { name: 'siemur/test-space-2', branches: 3, prs: 4, workspaces: 4, lastCommit: '20 minutes' }
+  ];
+
+  // In this example, expanded cells are tracked by the repo and property names from each row. This could be any pair of unique identifiers.
+  // This is to prevent state from being based on row and column order index in case we later add sorting and rearranging columns.
+  // Note that these columnKeys must be in the same order as the `columns` below, because columnIndex will be used to look up the matching key.
+  type ColumnKey = 'name' | 'branches' | 'prs' | 'workspaces' | 'lastCommit'; // For typechecking
+  const columnKeys: ColumnKey[] = ['name', 'branches', 'prs', 'workspaces', 'lastCommit']; // For indexed order
+  const [expandedCells, setExpandedCells] = React.useState<Record<string, ColumnKey>>({
+    'siemur/test-space': 'branches' // Default to the first cell of the first row being expanded
+  });
+  const setCellExpanded = (repo: Repository, columnKey: ColumnKey, isExpanding = true) => {
+    const newExpandedCells = { ...expandedCells };
+    if (isExpanding) {
+      newExpandedCells[repo.name] = columnKey;
+    } else {
+      delete newExpandedCells[repo.name];
+    }
+    setExpandedCells(newExpandedCells);
+  };
+
+  // We want to be able to reference the original data object based on row index. But because parent/child rows are
+  // multiple elements in the rows array, 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'] = [
+    'Repositories',
+    {
+      title: 'Branches',
+      cellTransforms: [compoundExpand]
+    },
+    {
+      title: 'Pull requests',
+      cellTransforms: [compoundExpand]
+    },
+    {
+      title: 'Workspaces',
+      cellTransforms: [compoundExpand]
+    },
+    'Last Commit',
+    {
+      title: '',
+      dataLabel: 'Action'
+    }
+  ];
+  const rows: TableProps['rows'] = [];
+  repositories.forEach(repo => {
+    const expandedCellKey = expandedCells[repo.name];
+    const isRowExpanded = !!expandedCellKey;
+    rows.push({
+      isOpen: isRowExpanded,
+      cells: [
+        { title: <a href="#">{repo.name}</a>, props: { component: 'th' } },
+        {
+          title: (
+            <React.Fragment>
+              <CodeBranchIcon key="icon" /> {repo.branches}
+            </React.Fragment>
+          ),
+          props: {
+            isOpen: expandedCellKey === 'branches',
+            ariaControls: `compound-expansion-table-${repo.name}-1`
+          }
+        },
+        {
+          title: (
+            <React.Fragment>
+              <CodeIcon key="icon" /> {repo.prs}
+            </React.Fragment>
+          ),
+          props: {
+            isOpen: expandedCellKey === 'prs',
+            ariaControls: `compound-expansion-table-${repo.name}-2`
+          }
+        },
+        {
+          title: (
+            <React.Fragment>
+              <CubeIcon key="icon" /> {repo.branches}
+            </React.Fragment>
+          ),
+          props: {
+            isOpen: expandedCellKey === 'workspaces',
+            ariaControls: `compound-expansion-table-${repo.name}-3`
+          }
+        },
+        repo.lastCommit,
+        { title: <a href="#">Open in Github</a> }
+      ]
+    });
+    reposByRowIndex.push(repo);
+    const parentIndex = rows.length - 1;
+    rows.push({
+      parent: parentIndex,
+      compoundParent: 1,
+      cells: [
+        {
+          title: (
+            <div className="pf-u-m-md" id={`compound-expansion-table-${repo.name}-1`}>
+              Expanded content for {repo.name}: Branches goes here!
+            </div>
+          ),
+          props: { colSpan: 6, className: 'pf-m-no-padding' }
+        }
+      ]
+    });
+    reposByRowIndex.push(null);
+    rows.push({
+      parent: parentIndex,
+      compoundParent: 2,
+      cells: [
+        {
+          title: (
+            <div className="pf-u-m-md" id={`compound-expansion-table-${repo.name}-2`}>
+              Expanded content for {repo.name}: Pull requests goes here!
+            </div>
+          ),
+          props: { colSpan: 6, className: 'pf-m-no-padding' }
+        }
+      ]
+    });
+    reposByRowIndex.push(null);
+    rows.push({
+      parent: parentIndex,
+      compoundParent: 3,
+      cells: [
+        {
+          title: (
+            <div className="pf-u-m-md" id={`compound-expansion-table-${repo.name}-3`}>
+              Expanded content for {repo.name}: Workspaces goes here!
+            </div>
+          ),
+          props: { colSpan: 6, className: 'pf-m-no-padding' }
+        }
+      ]
+    });
+    reposByRowIndex.push(null);
+  });
+
+  return (
+    <Table
+      aria-label="Compound expandable table"
+      onExpand={(_event, rowIndex, colIndex, isOpen) => {
+        if (reposByRowIndex[rowIndex]) {
+          setCellExpanded(reposByRowIndex[rowIndex], columnKeys[colIndex], !isOpen);
+        }
+      }}
+      rows={rows}
+      cells={columns}
+    >
+      <TableHeader />
+      <TableBody />
+    </Table>
+  );
+};

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

@@ -0,0 +1,51 @@
+import React from 'react';
+import {
+  Table,
+  TableHeader,
+  TableBody,
+  cellWidth,
+  truncate,
+  breakWord,
+  wrappable,
+  fitContent,
+  nowrap,
+  TableProps
+} from '@patternfly/react-table';
+
+// This example has been simplified to focus on the text modifier props. In real usage,
+// you may want to derive your rows from typed underlying data and minimal state. See other examples.
+
+export const LegacyTableControllingText: React.FunctionComponent = () => {
+  const columns: TableProps['cells'] = [
+    { title: 'Truncate (width 20%)', transforms: [cellWidth(20)], cellTransforms: [truncate] },
+    { title: 'Break word', cellTransforms: [breakWord] },
+    { title: 'Wrapping table header text. This th text will wrap instead of truncate.', transforms: [wrappable] },
+    { title: 'Fit content', transforms: [fitContent] },
+    { title: '', cellTransforms: [nowrap] }
+  ];
+  const rows: TableProps['rows'] = [
+    [
+      'This text will truncate instead of wrap.',
+      { title: <a href="#">http://thisisaverylongurlthatneedstobreakusethebreakwordmodifier.org</a> },
+      {
+        title: (
+          <p>
+            By default,
+            <code>thead</code> cells will truncate and
+            <code>tbody</code> cells will wrap. Use
+            <code>transforms</code> and/or <code>cellTransforms</code> to change the behavior.
+          </p>
+        )
+      },
+      "This cell's content will adjust itself to the parent th width. This modifier only affects table layouts.",
+      { title: <a href="#">No wrap</a> }
+    ]
+  ];
+
+  return (
+    <Table aria-label="Controlling text" cells={columns} rows={rows}>
+      <TableHeader />
+      <TableBody />
+    </Table>
+  );
+};

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