@patternfly/react-table 4.44.11 → 4.44.15

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

@@ -0,0 +1,90 @@
+import React from 'react';
+import { Table, TableHeader, TableBody, TableProps } from '@patternfly/react-table';
+import { ToggleGroup, ToggleGroupItem, ToggleGroupItemProps } from '@patternfly/react-core';
+interface Repository {
+  name: string;
+  branches: string;
+  prs: string;
+  workspaces: string;
+  lastCommit: string;
+}
+
+type ExampleType = 'default' | 'compact' | 'compactBorderless';
+
+export const LegacyTableBasic: 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: 'Repository two',
+      branches: 'Branch two',
+      prs: 'PR two',
+      workspaces: 'Workspace two',
+      lastCommit: 'Commit two'
+    },
+    {
+      name: 'Repository three',
+      branches: 'Branch three',
+      prs: 'PR three',
+      workspaces: 'Workspace three',
+      lastCommit: 'Commit three'
+    }
+  ];
+
+  // This state is just for the ToggleGroup in this example and isn't necessary for TableComposable usage.
+  const [exampleChoice, setExampleChoice] = React.useState<ExampleType>('default');
+  const onExampleTypeChange: ToggleGroupItemProps['onChange'] = (_isSelected, event) => {
+    const id = event.currentTarget.id;
+    setExampleChoice(id as ExampleType);
+  };
+
+  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
+  ]);
+
+  return (
+    <React.Fragment>
+      <ToggleGroup aria-label="Default with single selectable">
+        <ToggleGroupItem
+          text="Default"
+          buttonId="default"
+          isSelected={exampleChoice === 'default'}
+          onChange={onExampleTypeChange}
+        />
+        <ToggleGroupItem
+          text="Compact"
+          buttonId="compact"
+          isSelected={exampleChoice === 'compact'}
+          onChange={onExampleTypeChange}
+        />
+        <ToggleGroupItem
+          text="Compact borderless"
+          buttonId="compactBorderless"
+          isSelected={exampleChoice === 'compactBorderless'}
+          onChange={onExampleTypeChange}
+        />
+      </ToggleGroup>
+      <Table
+        aria-label="Simple Table"
+        variant={exampleChoice !== 'default' ? 'compact' : undefined}
+        borders={exampleChoice !== 'compactBorderless'}
+        cells={columns}
+        rows={rows}
+      >
+        <TableHeader />
+        <TableBody />
+      </Table>
+    </React.Fragment>
+  );
+};

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

@@ -0,0 +1,66 @@
+import React from 'react';
+import { Table, TableHeader, TableBody, classNames, cellWidth, Visibility, TableProps } from '@patternfly/react-table';
+
+interface Repository {
+  name: string;
+  branches: string;
+  prs: string;
+  workspaces: string;
+  lastCommit: string;
+}
+
+export const LegacyTableCellWidth: React.FunctionComponent = () => {
+  // In real usage, this data would come from some external source like an API via props.
+  const repositories: Repository[] = [
+    {
+      name: 'one - 1',
+      branches: 'two - 1 (visible only on md)',
+      prs: 'three - 1 (hidden only on md)',
+      workspaces: 'four - 1 (hidden on xs)',
+      lastCommit: 'five - 1'
+    },
+    {
+      name: 'one - 2',
+      branches: 'two - 2 (visible only on md)',
+      prs: 'three - 2 (hidden only on md)',
+      workspaces: 'four - 2 (hidden on xs)',
+      lastCommit: 'five - 2'
+    }
+  ];
+
+  const columns: TableProps['cells'] = [
+    { title: 'Header cell', transforms: [cellWidth(10)] },
+    {
+      title: 'Branches (visible only on md and 2Xl)',
+      columnTransforms: [
+        classNames(Visibility.hidden, Visibility.visibleOnMd, Visibility.hiddenOnLg, Visibility.visibleOn2Xl)
+      ]
+    },
+    {
+      title: 'Pull requests (hidden only on md)',
+      columnTransforms: [classNames(Visibility.hiddenOnMd, Visibility.visibleOnLg)]
+    },
+    {
+      title: 'Workspaces (hidden on xs)',
+      columnTransforms: [classNames(Visibility.hidden, Visibility.visibleOnSm)]
+    },
+    {
+      title: 'Last commit',
+      transforms: [cellWidth(30)]
+    }
+  ];
+  const rows: TableProps['rows'] = repositories.map(repo => [
+    repo.name,
+    repo.branches,
+    repo.prs,
+    repo.workspaces,
+    repo.lastCommit
+  ]);
+
+  return (
+    <Table aria-label="Table with width and breakpoint visibility modifiers" cells={columns} rows={rows}>
+      <TableHeader />
+      <TableBody />
+    </Table>
+  );
+};

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