@patternfly/react-core 4.237.6 → 4.237.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@patternfly/react-core",
-  "version": "4.237.6",
+  "version": "4.237.9",
   "description": "This library provides a set of common React components for use with the PatternFly reference implementation.",
   "main": "dist/js/index.js",
   "module": "dist/esm/index.js",
@@ -44,16 +44,16 @@
     "generate": "node scripts/copyStyles.js"
   },
   "dependencies": {
-    "@patternfly/react-icons": "^4.88.6",
-    "@patternfly/react-styles": "^4.87.6",
-    "@patternfly/react-tokens": "^4.89.6",
+    "@patternfly/react-icons": "^4.88.9",
+    "@patternfly/react-styles": "^4.87.9",
+    "@patternfly/react-tokens": "^4.89.9",
     "focus-trap": "6.9.2",
     "react-dropzone": "9.0.0",
     "tippy.js": "5.1.2",
     "tslib": "^2.0.0"
   },
   "devDependencies": {
-    "@patternfly/patternfly": "4.214.1",
+    "@patternfly/patternfly": "4.215.0",
     "@rollup/plugin-commonjs": "^21.0.0",
     "@rollup/plugin-node-resolve": "^13.0.0",
     "@rollup/plugin-replace": "^3.0.0",
@@ -70,5 +70,5 @@
     "react": "^16.8.0 || ^17.0.0",
     "react-dom": "^16.8.0 || ^17.0.0"
   },
-  "gitHead": "55fff2303d14e704bf9c55a5d5f2866e16a83a05"
+  "gitHead": "0acf9a0fe23232defeddaaf3001cf6846702a8cf"
 }

package/src/components/Button/examples/Button.md

@@ -96,21 +96,9 @@ Router links can be used for in-app linking in React environments to prevent pag
 
 Buttons that are aria-disabled are similar to normal disabled buttons, except they can receive focus. Every button variant can be aria-disabled using the `isAriaDisabled` property.
 
-```ts file="./ButtonAriaDisabled.tsx"
-```
-
-### Aria-disabled with tooltip
-
-Unlike normal disabled buttons, aria-disabled buttons can support tooltips.
-
-```ts file="./ButtonAriaDisabledTooltip.tsx"
-```
-
-### Aria-disabled link as button with tooltip
-
-Aria-disabled buttons can operate as links, which also support tooltips.
+Unlike normal disabled buttons, aria-disabled buttons can support tooltips. Furthermore, aria-disabled buttons can operate as links, which also support tooltips.
 
-```ts file="./ButtonAriaDisabledLinkTooltip.tsx"
+```ts file="./ButtonAriaDisabled.tsx"
 ```
 
 ### Button with count
@@ -118,4 +106,4 @@ Aria-disabled buttons can operate as links, which also support tooltips.
 Buttons can display a `count` in the form of a badge to indicate some value or number by passing in the `countOptions` prop as a `BadgeCountObject` object. The `BadgeCountObject` object will handle `count`, `isRead`, and `className` props for the badge count.
 
 ```ts file="./ButtonWithCount.tsx" isBeta
-```
+```

package/src/components/Button/examples/ButtonAriaDisabled.tsx

@@ -1,11 +1,12 @@
 import React from 'react';
-import { Button } from '@patternfly/react-core';
+import { Button, Tooltip } from '@patternfly/react-core';
 import TimesIcon from '@patternfly/react-icons/dist/esm/icons/times-icon';
 import PlusCircleIcon from '@patternfly/react-icons/dist/esm/icons/plus-circle-icon';
 
 export const ButtonAriaDisabled: React.FunctionComponent = () => (
   <React.Fragment>
-    <Button isAriaDisabled>Primary aria disabled</Button> <Button isAriaDisabled>Secondary aria disabled</Button>{' '}
+    <Button isAriaDisabled>Primary aria disabled</Button>
+    <Button isAriaDisabled>Secondary aria disabled</Button>{' '}
     <Button variant="secondary" isDanger isAriaDisabled>
       Danger secondary aria disabled
     </Button>{' '}
@@ -35,5 +36,17 @@ export const ButtonAriaDisabled: React.FunctionComponent = () => (
     <Button isAriaDisabled variant="control">
       Control aria disabled
     </Button>
+    <br />
+    <br />
+    <Tooltip content="Aria-disabled buttons are like disabled buttons, but focusable. Allows for tooltip support.">
+      <Button isAriaDisabled variant="secondary">
+        Secondary button to core docs
+      </Button>
+    </Tooltip>{' '}
+    <Tooltip content="Aria-disabled link as button with tooltip">
+      <Button component="a" isAriaDisabled href="https://pf4.patternfly.org/" target="_blank" variant="tertiary">
+        Tertiary link as button to core docs
+      </Button>
+    </Tooltip>
   </React.Fragment>
 );

package/src/components/MenuToggle/MenuToggle.tsx

@@ -149,6 +149,7 @@ export class MenuToggleBase extends React.Component<MenuToggleProps> {
             aria-expanded={isExpanded}
             aria-label={ariaLabel}
             disabled={isDisabled}
+            onClick={onClick}
             {...otherProps}
           >
             {toggleControls}

package/src/components/MenuToggle/__tests__/MenuToggle.test.tsx

@@ -1,9 +1,11 @@
 import React from 'react';
-import { render } from '@testing-library/react';
 import { MenuToggle } from '../MenuToggle';
+import { MenuToggleCheckbox } from '../MenuToggleCheckbox';
 import { Badge } from '../../Badge';
 import CogIcon from '@patternfly/react-icons/dist/esm/icons/cog-icon';
 import EllipsisVIcon from '@patternfly/react-icons/dist/esm/icons/ellipsis-v-icon';
+import userEvent from '@testing-library/user-event';
+import { fireEvent, render, screen } from '@testing-library/react';
 
 describe('menu toggle', () => {
   test('renders successfully', () => {
@@ -54,4 +56,28 @@ describe('menu toggle', () => {
     const { asFragment } = render(<MenuToggle badge={<Badge>badge</Badge>}>Toggle</MenuToggle>);
     expect(asFragment()).toMatchSnapshot();
   });
+
+  test('split toggle passes onClick', async () => {
+    const mockClick = jest.fn();
+    const user = userEvent.setup();
+
+    render(<MenuToggle
+      onClick={mockClick}
+      splitButtonOptions={{
+        items: [
+          <MenuToggleCheckbox
+            id="split-button-checkbox-with-text-disabled-example"
+            key="split-checkbox-with-text-disabled"
+            aria-label="Select all"
+          >
+            10 selected
+          </MenuToggleCheckbox>
+        ]
+      }}
+      aria-label="Menu toggle with checkbox split button and text"
+    />);
+
+    await user.click(screen.getByRole(`button`) as Element);
+    expect(mockClick).toHaveBeenCalled();
+  });
 });

package/src/components/Text/examples/Text.md

@@ -125,7 +125,7 @@ import {
 </TextContent>;
 ```
 
-### Data list
+### Description list
 
 ```js
 import React from 'react';

package/src/demos/Filters/FilterDemos.md

@@ -0,0 +1,48 @@
+---
+id: Filters
+section: demos
+---
+
+import {
+Popper,
+SearchInput,
+Toolbar,
+ToolbarContent,
+ToolbarItem,
+Menu,
+MenuContent,
+MenuList,
+MenuItem,
+MenuToggle,
+MenuToggleCheckbox,
+ToolbarGroup,
+ToolbarFilter,
+Badge,
+Pagination,
+EmptyState,
+EmptyStateIcon,
+Title,
+EmptyStateBody,
+EmptyStatePrimary,
+Button
+} from '@patternfly/react-core';
+import FilterIcon from '@patternfly/react-icons/dist/esm/icons/filter-icon';
+import SearchIcon from '@patternfly/react-icons/dist/esm/icons/search-icon';
+import { TableComposable, Thead, Tr, Th, Tbody, Td } from '@patternfly/react-table';
+
+## Demos
+
+### Filtering with a search input
+
+```ts file="./examples/FilterSearchInput.tsx"
+```
+
+### Filtering with a single select
+
+```ts file="./examples/FilterSingleSelect.tsx"
+```
+
+### Filtering with a checkbox select
+
+```ts file="./examples/FilterCheckboxSelect.tsx"
+```

package/src/demos/Filters/examples/FilterCheckboxSelect.tsx

@@ -0,0 +1,405 @@
+import React from 'react';
+import {
+  Menu,
+  MenuContent,
+  MenuList,
+  MenuItem,
+  MenuToggle,
+  MenuToggleCheckbox,
+  Popper,
+  Toolbar,
+  ToolbarContent,
+  ToolbarGroup,
+  ToolbarFilter,
+  ToolbarItem,
+  Badge,
+  Pagination
+} from '@patternfly/react-core';
+import { TableComposable, Thead, Tr, Th, Tbody, Td } from '@patternfly/react-table';
+import FilterIcon from '@patternfly/react-icons/dist/esm/icons/filter-icon';
+
+interface Repository {
+  name: string;
+  threads: string;
+  apps: string;
+  workspaces: string;
+  status: string;
+  location: string;
+}
+
+// In real usage, this data would come from some external source like an API via props.
+const repositories: Repository[] = [
+  { name: 'US-Node 1', threads: '5', apps: '25', workspaces: '5', status: 'Stopped', location: 'Raleigh' },
+  { name: 'US-Node 2', threads: '5', apps: '30', workspaces: '2', status: 'Down', location: 'Westford' },
+  { name: 'US-Node 3', threads: '13', apps: '35', workspaces: '12', status: 'Degraded', location: 'Boston' },
+  { name: 'US-Node 4', threads: '2', apps: '5', workspaces: '18', status: 'Needs Maintainence', location: 'Raleigh' },
+  { name: 'US-Node 5', threads: '7', apps: '30', workspaces: '5', status: 'Running', location: 'Boston' },
+  { name: 'US-Node 6', threads: '5', apps: '20', workspaces: '15', status: 'Stopped', location: 'Raleigh' },
+  { name: 'CZ-Node 1', threads: '12', apps: '48', workspaces: '13', status: 'Down', location: 'Brno' },
+  { name: 'CZ-Node 2', threads: '3', apps: '8', workspaces: '20', status: 'Running', location: 'Brno' },
+  { name: 'CZ-Remote-Node 1', threads: '1', apps: '15', workspaces: '20', status: 'Down', location: 'Brno' },
+  { name: 'Bangalore-Node 1', threads: '1', apps: '20', workspaces: '20', status: 'Running', location: 'Bangalore' }
+];
+
+const columnNames = {
+  name: 'Servers',
+  threads: 'Threads',
+  apps: 'Applications',
+  workspaces: 'Workspaces',
+  status: 'Status',
+  location: 'Location'
+};
+
+/* eslint-disable patternfly-react/no-anonymous-functions */
+export const FilterCheckboxSelect: React.FunctionComponent = () => {
+  // Set up table selection
+  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 areAllReposSelected = selectedRepoNames.length === selectableRepos.length;
+  const areSomeReposSelected = selectedRepoNames.length > 0;
+  const isRepoSelected = (repo: Repository) => selectedRepoNames.includes(repo.name);
+
+  // 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);
+    };
+  }, []);
+
+  // Set up bulk selection menu
+  const bulkSelectMenuRef = React.createRef<HTMLDivElement>();
+  const bulkSelectToggleRef = React.createRef<any>();
+  const bulkSelectcontainerRef = React.createRef<HTMLDivElement>();
+
+  const [isBulkSelectOpen, setIsBulkSelectOpen] = React.useState<boolean>(false);
+
+  React.useEffect(() => {
+    window.addEventListener('keydown', handleBulkSelectMenuKeys);
+    window.addEventListener('click', handleBulkSelectClickOutside);
+    return () => {
+      window.removeEventListener('keydown', handleBulkSelectMenuKeys);
+      window.removeEventListener('click', handleBulkSelectClickOutside);
+    };
+  }, [isBulkSelectOpen, bulkSelectMenuRef]);
+
+  const handleBulkSelectClickOutside = (event: MouseEvent) => {
+    if (isBulkSelectOpen && !bulkSelectMenuRef.current?.contains(event.target as Node)) {
+      setIsBulkSelectOpen(false);
+    }
+  };
+
+  const handleBulkSelectMenuKeys = (event: KeyboardEvent) => {
+    if (!isBulkSelectOpen) {
+      return;
+    }
+    if (
+      bulkSelectMenuRef.current?.contains(event.target as Node) ||
+      bulkSelectToggleRef.current?.contains(event.target as Node)
+    ) {
+      if (event.key === 'Escape' || event.key === 'Tab') {
+        setIsBulkSelectOpen(!isBulkSelectOpen);
+        bulkSelectToggleRef.current?.focus();
+      }
+    }
+  };
+
+  const onBulkSelectToggleClick = (ev: React.MouseEvent) => {
+    ev.stopPropagation(); // Stop handleClickOutside from handling
+    setTimeout(() => {
+      if (bulkSelectMenuRef.current) {
+        const firstElement = bulkSelectMenuRef.current.querySelector('li > button:not(:disabled)');
+        firstElement && (firstElement as HTMLElement).focus();
+      }
+    }, 0);
+    setIsBulkSelectOpen(!isBulkSelectOpen);
+  };
+
+  let menuToggleCheckmark: boolean | null = false;
+  if (areAllReposSelected) {
+    menuToggleCheckmark = true;
+  } else if (areSomeReposSelected) {
+    menuToggleCheckmark = null;
+  }
+
+  const bulkSelectToggle = (
+    <MenuToggle
+      ref={bulkSelectToggleRef}
+      onClick={onBulkSelectToggleClick}
+      isExpanded={isBulkSelectOpen}
+      splitButtonOptions={{
+        items: [
+          <MenuToggleCheckbox
+            id="select-checkbox"
+            key="select-checkbox"
+            aria-label="Select all"
+            isChecked={menuToggleCheckmark}
+            onChange={(checked, _event) => selectAllRepos(checked)}
+          />
+        ]
+      }}
+      aria-label="Full table selection checkbox"
+    />
+  );
+
+  const bulkSelectMenu = (
+    // eslint-disable-next-line no-console
+    <Menu
+      ref={bulkSelectMenuRef}
+      onSelect={(_ev, itemId) => {
+        selectAllRepos(itemId === 1 || itemId === 2);
+        setIsBulkSelectOpen(!isBulkSelectOpen);
+      }}
+    >
+      <MenuContent>
+        <MenuList>
+          <MenuItem itemId={0}>Select none (0 items)</MenuItem>
+          <MenuItem itemId={1}>Select page ({repositories.length} items)</MenuItem>
+          <MenuItem itemId={2}>Select all ({repositories.length} items)</MenuItem>
+        </MenuList>
+      </MenuContent>
+    </Menu>
+  );
+
+  const toolbarBulkSelect = (
+    <div ref={bulkSelectcontainerRef}>
+      <Popper
+        trigger={bulkSelectToggle}
+        popper={bulkSelectMenu}
+        appendTo={bulkSelectcontainerRef.current || undefined}
+        isVisible={isBulkSelectOpen}
+        popperMatchesTriggerWidth={false}
+      />
+    </div>
+  );
+
+  // Set up single select menu & state
+  const [isOpen, setIsOpen] = React.useState<boolean>(false);
+  const [selections, setSelections] = React.useState<string[]>([]);
+  const toggleRef = React.useRef<HTMLButtonElement>(null);
+  const menuRef = React.useRef<HTMLDivElement>(null);
+  const containerRef = React.useRef<HTMLDivElement>(null);
+
+  const onFilter = (repo: Repository) => {
+    if (selections.length === 0) {
+      return true;
+    }
+
+    return selections.some(searchValue => {
+      let input: RegExp;
+      try {
+        input = new RegExp(searchValue, 'i');
+      } catch (err) {
+        input = new RegExp(searchValue.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'i');
+      }
+      return repo.location.search(input) >= 0;
+    });
+  };
+
+  const handleMenuKeys = (event: KeyboardEvent) => {
+    if (isOpen && menuRef.current?.contains(event.target as Node)) {
+      if (event.key === 'Escape' || event.key === 'Tab') {
+        setIsOpen(!isOpen);
+        toggleRef.current?.focus();
+      }
+    }
+  };
+
+  const handleClickOutside = (event: MouseEvent) => {
+    if (isOpen && !menuRef.current?.contains(event.target as Node)) {
+      setIsOpen(false);
+    }
+  };
+
+  React.useEffect(() => {
+    window.addEventListener('keydown', handleMenuKeys);
+    window.addEventListener('click', handleClickOutside);
+    return () => {
+      window.removeEventListener('keydown', handleMenuKeys);
+      window.removeEventListener('click', handleClickOutside);
+    };
+  }, [isOpen, menuRef]);
+
+  const onToggleClick = (ev: React.MouseEvent) => {
+    ev.stopPropagation(); // Stop handleClickOutside from handling
+    setTimeout(() => {
+      if (menuRef.current) {
+        const firstElement = menuRef.current.querySelector('li > button:not(:disabled)');
+        firstElement && (firstElement as HTMLElement).focus();
+      }
+    }, 0);
+    setIsOpen(!isOpen);
+  };
+
+  function onSelect(event: React.MouseEvent | undefined, itemId: string | number | undefined) {
+    if (typeof itemId === 'undefined') {
+      return;
+    }
+
+    const itemStr = itemId.toString();
+    setSelections(
+      selections.includes(itemStr) ? selections.filter(selection => selection !== itemStr) : [itemStr, ...selections]
+    );
+  }
+
+  const toggle = (
+    <MenuToggle
+      ref={toggleRef}
+      onClick={onToggleClick}
+      isExpanded={isOpen}
+      icon={<FilterIcon />}
+      {...(selections.length > 0 && { badge: <Badge isRead>{selections.length}</Badge> })}
+      style={
+        {
+          width: '200px'
+        } as React.CSSProperties
+      }
+    >
+      Location
+    </MenuToggle>
+  );
+
+  const menu = (
+    <Menu ref={menuRef} id="select-menu" onSelect={onSelect} selected={selections}>
+      <MenuContent>
+        <MenuList>
+          <MenuItem hasCheck isSelected={selections.includes('Bangalore')} itemId="Bangalore">
+            Bangalore
+          </MenuItem>
+          <MenuItem hasCheck isSelected={selections.includes('Boston')} itemId="Boston">
+            Boston
+          </MenuItem>
+          <MenuItem hasCheck isSelected={selections.includes('Brno')} itemId="Brno">
+            Brno
+          </MenuItem>
+          <MenuItem hasCheck isSelected={selections.includes('Raleigh')} itemId="Raleigh">
+            Raleigh
+          </MenuItem>
+          <MenuItem hasCheck isSelected={selections.includes('Westford')} itemId="Westford">
+            Westford
+          </MenuItem>
+        </MenuList>
+      </MenuContent>
+    </Menu>
+  );
+
+  const select = (
+    <div ref={containerRef}>
+      <Popper trigger={toggle} popper={menu} appendTo={containerRef.current || undefined} isVisible={isOpen} />
+    </div>
+  );
+
+  // Set up pagination
+  const toolbarPagination = (
+    <Pagination
+      titles={{ paginationTitle: 'Checkbox filter pagination' }}
+      perPageComponent="button"
+      itemCount={repositories.length}
+      perPage={10}
+      page={1}
+      widgetId="checkbox-select-mock-pagination"
+      isCompact
+    />
+  );
+
+  const toolbar = (
+    <Toolbar id="checkbox-filter-toolbar" clearAllFilters={() => setSelections([])}>
+      <ToolbarContent>
+        <ToolbarItem>{toolbarBulkSelect}</ToolbarItem>
+        <ToolbarGroup variant="filter-group">
+          <ToolbarFilter
+            chips={selections}
+            deleteChip={(category, chip) => onSelect(undefined, chip as string)}
+            deleteChipGroup={() => setSelections([])}
+            categoryName="Location"
+          >
+            {select}
+          </ToolbarFilter>
+        </ToolbarGroup>
+        <ToolbarItem variant="pagination">{toolbarPagination}</ToolbarItem>
+      </ToolbarContent>
+    </Toolbar>
+  );
+
+  return (
+    <React.Fragment>
+      {toolbar}
+      <TableComposable aria-label="Selectable table">
+        <Thead>
+          <Tr>
+            <Th />
+            <Th width={20}>{columnNames.name}</Th>
+            <Th width={20}>{columnNames.threads}</Th>
+            <Th width={20}>{columnNames.apps}</Th>
+            <Th width={20}>{columnNames.workspaces}</Th>
+            <Th width={20}>{columnNames.status}</Th>
+            <Th width={20}>{columnNames.location}</Th>
+          </Tr>
+        </Thead>
+        <Tbody>
+          {repositories.filter(onFilter).map((repo, rowIndex) => (
+            <Tr key={repo.name}>
+              <Td
+                select={{
+                  rowIndex,
+                  onSelect: (_event, isSelecting) => onSelectRepo(repo, rowIndex, isSelecting),
+                  isSelected: isRepoSelected(repo),
+                  disable: !isRepoSelectable(repo)
+                }}
+              />
+              <Td dataLabel={columnNames.name}>{repo.name}</Td>
+              <Td dataLabel={columnNames.threads}>{repo.threads}</Td>
+              <Td dataLabel={columnNames.apps}>{repo.apps}</Td>
+              <Td dataLabel={columnNames.workspaces}>{repo.workspaces}</Td>
+              <Td dataLabel={columnNames.status}>{repo.status}</Td>
+              <Td dataLabel={columnNames.location}>{repo.location}</Td>
+            </Tr>
+          ))}
+        </Tbody>
+      </TableComposable>
+    </React.Fragment>
+  );
+};