@patternfly/react-table 4.44.12 → 4.44.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@patternfly/react-table",
-  "version": "4.44.12",
+  "version": "4.44.16",
   "description": "This library provides a set of React table components for use with the PatternFly 4",
   "main": "dist/js/index.js",
   "module": "dist/esm/index.js",
@@ -31,10 +31,10 @@
     "clean": "rimraf dist"
   },
   "dependencies": {
-    "@patternfly/react-core": "^4.175.12",
-    "@patternfly/react-icons": "^4.26.12",
-    "@patternfly/react-styles": "^4.25.12",
-    "@patternfly/react-tokens": "^4.27.12",
+    "@patternfly/react-core": "^4.175.16",
+    "@patternfly/react-icons": "^4.26.16",
+    "@patternfly/react-styles": "^4.25.16",
+    "@patternfly/react-tokens": "^4.27.16",
     "lodash": "^4.17.19",
     "tslib": "^2.0.0"
   },
@@ -46,5 +46,5 @@
     "react": "^16.8.0 || ^17.0.0",
     "react-dom": "^16.8.0 || ^17.0.0"
   },
-  "gitHead": "c31cf1714bb3cbb692b22861c6c8204d59243d83"
+  "gitHead": "0fd305f905deef067794578e91429e8fcf85515c"
 }

package/src/components/Table/Table.tsx

@@ -32,6 +32,7 @@ import {
   OnFavorite
 } from './TableTypes';
 import { TreeRowWrapper } from './TreeRowWrapper';
+import { CustomActionsToggleProps } from './ActionsColumn';
 
 export interface TableProps extends OUIAProps {
   /** Adds an accessible name for the Table */
@@ -89,7 +90,7 @@ export interface TableProps extends OUIAProps {
   /** The desired direction to show the dropdown when clicking on the actions Kebab. Can only be used together with `actions` property */
   dropdownDirection?: 'up' | 'down';
   /** The toggle of the actions menu dropdown. A KebabToggle or DropdownToggle component */
-  actionsToggle?: React.ReactElement;
+  actionsToggle?: (props: CustomActionsToggleProps) => React.ReactNode;
   /** Row data */
   rows: (IRow | string[])[];
   /** Cell/column data */

package/src/components/Table/TableTypes.tsx

@@ -7,6 +7,7 @@ import {
 } from '@patternfly/react-core/dist/esm/components/Dropdown/dropdownConstants';
 import * as React from 'react';
 import { CustomActionsToggleProps } from './ActionsColumn';
+import { ButtonProps } from '@patternfly/react-core';
 
 export enum TableGridBreakpoint {
   none = '',
@@ -145,7 +146,7 @@ export interface ISortBy {
   defaultDirection?: 'asc' | 'desc';
 }
 
-export interface IAction extends Omit<DropdownItemProps, 'title' | 'onClick'> {
+export interface IAction extends Omit<DropdownItemProps, 'title' | 'onClick'>, Pick<ButtonProps, 'variant'> {
   /** Flag indicating an item on actions menu is a separator, rather than an action */
   isSeparator?: boolean;
   /** Key of actions menu item */

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

@@ -0,0 +1,218 @@
+/* eslint-disable no-console */
+import React from 'react';
+import {
+  ButtonVariant,
+  Checkbox,
+  DropdownToggle,
+  ToggleGroup,
+  ToggleGroupItem,
+  ToggleGroupItemProps,
+  Toolbar,
+  ToolbarContent,
+  ToolbarItem
+} from '@patternfly/react-core';
+import {
+  CustomActionsToggleProps,
+  headerCol,
+  TableProps,
+  IAction,
+  IActions,
+  IActionsResolver,
+  Table,
+  TableBody,
+  TableHeader
+} from '@patternfly/react-table';
+
+interface Repository {
+  name: string;
+  branches: string;
+  prs: string;
+  workspaces: string;
+  lastCommit: string;
+}
+
+type ExampleType = 'actions' | 'actionResolver';
+
+export const LegacyTableActions: React.FunctionComponent = () => {
+  // In real usage, this data would come from some external source like an API via props.
+  const repositories: Repository[] = [
+    { name: 'a', branches: 'two', prs: '1', workspaces: 'four', lastCommit: 'five' },
+    { name: 'disable actions', branches: 'two', prs: '3', workspaces: 'four', lastCommit: 'five' },
+    { name: 'green actions', branches: 'two', prs: '4', workspaces: 'four', lastCommit: 'five' },
+    { name: 'extra action props', branches: 'two', prs: '5', workspaces: 'four', lastCommit: 'five' },
+    { name: 'blue actions', branches: 'two', prs: '6', workspaces: 'four', lastCommit: 'five' }
+  ];
+
+  // This state is just for the ToggleGroup in this example and isn't necessary for Table usage.
+  const [propToUse, setPropToUse] = React.useState<ExampleType>('actions');
+  const onPropToUseChange: ToggleGroupItemProps['onChange'] = (_isSelected, event) => {
+    const id = event.currentTarget.id;
+    setPropToUse(id as ExampleType);
+  };
+
+  const [useCustomToggle, setUseCustomToggle] = React.useState(false);
+  const [useExtraAction, setUseExtraAction] = React.useState(false);
+
+  const customActionsToggle = (props: CustomActionsToggleProps) => (
+    <DropdownToggle onToggle={props.onToggle} isDisabled={props.isDisabled}>
+      Actions
+    </DropdownToggle>
+  );
+
+  const columns: TableProps['cells'] = [
+    { title: 'Repositories', cellTransforms: [headerCol()] },
+    'Branches',
+    'Pull requests',
+    'Workspaces',
+    'Last commit'
+  ];
+  const rows: TableProps['rows'] = repositories.map(repo => {
+    const cells = [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 === 'disable actions') {
+      return { cells, disableActions: true };
+    }
+    if (repo.name === 'green actions') {
+      return { cells, type: 'green' };
+    }
+    if (repo.name === 'extra action props') {
+      return { cells, actionProps: { 'data-specific-attr': 'some-value' } };
+    }
+    if (repo.name === 'blue actions') {
+      return { cells, type: 'blue' };
+    }
+    return { cells };
+  });
+
+  /**
+   * Use actions or actionResolver, not both
+   */
+  const extraAction: IAction = {
+    title: 'Start',
+    variant: ButtonVariant.secondary,
+    onClick: (_event, rowId, rowData, extra) => console.log('clicked on extra action on row: ', rowId, rowData, extra),
+    isOutsideDropdown: true
+  };
+  const actions: IActions = [
+    {
+      title: 'Some action',
+      onClick: (_event, rowId, rowData, extra) => console.log('clicked on Some action, on row: ', rowId, rowData, extra)
+    },
+    {
+      title: <a href="#">Link action</a>
+    },
+    {
+      isSeparator: true
+    },
+    {
+      title: 'Third action',
+      onClick: (_event, rowId, rowData, extra) =>
+        console.log('clicked on Third action, on row: ', rowId, rowData, extra)
+    },
+    ...(useExtraAction ? [extraAction] : [])
+  ];
+
+  /**
+   * Use actions or actionResolver, not both
+   */
+  const actionResolver: IActionsResolver = (rowData, { rowIndex }) => {
+    if (rowIndex === 1) {
+      return [];
+    }
+
+    const extraAction: IActions = [
+      {
+        title: 'Start',
+        variant: ButtonVariant.secondary,
+        onClick: (_event, rowId, rowData, extra) =>
+          console.log('clicked on extra action on row: ', rowId, rowData, extra),
+        isOutsideDropdown: true
+      }
+    ];
+
+    const thirdAction: IActions = [
+      {
+        isSeparator: true
+      },
+      {
+        title: `${rowData.type} action`,
+        onClick: (_event, rowId, rowData, extra) =>
+          console.log(`clicked on ${rowData.type} action, on row ${rowId} of type ${rowData.type}`, extra)
+      }
+    ];
+
+    return [
+      ...(useExtraAction ? extraAction : []),
+      {
+        title: 'actionResolver action',
+        onClick: (_event, rowId, rowData, extra) =>
+          console.log(`clicked on Some action, on row ${rowId} of type ${rowData.type}`, extra)
+      },
+      {
+        title: <div>Another action</div>,
+        onClick: (_event, rowId, rowData, extra) =>
+          console.log(`clicked on Another action, on row ${rowId} of type ${rowData.type}`, extra)
+      },
+      ...(rowData.type ? thirdAction : [])
+    ];
+  };
+
+  return (
+    <React.Fragment>
+      <Toolbar>
+        <ToolbarContent>
+          <ToolbarItem>
+            <ToggleGroup aria-label="actions or actionResolver">
+              <ToggleGroupItem
+                text="Use actions prop"
+                buttonId="actions"
+                isSelected={propToUse === 'actions'}
+                onChange={onPropToUseChange}
+              />
+              <ToggleGroupItem
+                text="Use actionResolver prop"
+                buttonId="actionResolver"
+                isSelected={propToUse === 'actionResolver'}
+                onChange={onPropToUseChange}
+              />
+            </ToggleGroup>
+          </ToolbarItem>
+          <ToolbarItem>
+            <Checkbox
+              label="Use custom actions toggle"
+              isChecked={useCustomToggle}
+              onChange={setUseCustomToggle}
+              aria-label="toggle use of custom actions toggle"
+              id="toggle-custom-actions-toggle"
+              name="toggle-custom-actions-toggle"
+            />
+          </ToolbarItem>
+          <ToolbarItem>
+            <Checkbox
+              label="Add extra actions"
+              isChecked={useExtraAction}
+              onChange={setUseExtraAction}
+              aria-label="toggle extra actions"
+              id="toggle-extra-action"
+              name="toggle-extra-action"
+            />
+          </ToolbarItem>
+        </ToolbarContent>
+      </Toolbar>
+      <Table
+        aria-label="Actions table"
+        cells={columns}
+        rows={rows}
+        {...(propToUse === 'actions' && { actions })}
+        {...(propToUse === 'actionResolver' && { actionResolver })}
+        areActionsDisabled={rowData => !!rowData.disableActions}
+        dropdownPosition="left"
+        dropdownDirection="down"
+        actionsToggle={useCustomToggle ? customActionsToggle : undefined}
+      >
+        <TableHeader />
+        <TableBody />
+      </Table>
+    </React.Fragment>
+  );
+};

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