@patternfly/react-core 5.4.0-prerelease.2 → 5.4.0-prerelease.20

package/src/components/Select/examples/SelectTypeaheadCreatable.tsx

@@ -29,10 +29,11 @@ export const SelectTypeaheadCreatable: React.FunctionComponent = () => {
   const [filterValue, setFilterValue] = React.useState<string>('');
   const [selectOptions, setSelectOptions] = React.useState<SelectOptionProps[]>(initialSelectOptions);
   const [focusedItemIndex, setFocusedItemIndex] = React.useState<number | null>(null);
-  const [activeItem, setActiveItem] = React.useState<string | null>(null);
-  const [onCreation, setOnCreation] = React.useState<boolean>(false); // Boolean to refresh filter state after new option is created
+  const [activeItemId, setActiveItemId] = React.useState<string | null>(null);
   const textInputRef = React.useRef<HTMLInputElement>();
 
+  const CREATE_NEW = 'create';
+
   React.useEffect(() => {
     let newSelectOptions: SelectOptionProps[] = initialSelectOptions;
 
@@ -42,9 +43,9 @@ export const SelectTypeaheadCreatable: React.FunctionComponent = () => {
         String(menuItem.children).toLowerCase().includes(filterValue.toLowerCase())
       );
 
-      // When no options are found after filtering, display creation option
-      if (!newSelectOptions.length) {
-        newSelectOptions = [{ isDisabled: false, children: `Create new option "${filterValue}"`, value: 'create' }];
+      // If no option matches the filter exactly, display creation option
+      if (!initialSelectOptions.some((option) => option.value === filterValue)) {
+        newSelectOptions = [...newSelectOptions, { children: `Create new option "${filterValue}"`, value: CREATE_NEW }];
       }
 
       // Open the menu when the input value changes and the new value is not empty
@@ -54,96 +55,133 @@ export const SelectTypeaheadCreatable: React.FunctionComponent = () => {
     }
 
     setSelectOptions(newSelectOptions);
-    setActiveItem(null);
+  }, [filterValue]);
+
+  const createItemId = (value: any) => `select-typeahead-${value.replace(' ', '-')}`;
+
+  const setActiveAndFocusedItem = (itemIndex: number) => {
+    setFocusedItemIndex(itemIndex);
+    const focusedItem = selectOptions[itemIndex];
+    setActiveItemId(createItemId(focusedItem.value));
+  };
+
+  const resetActiveAndFocusedItem = () => {
     setFocusedItemIndex(null);
-  }, [filterValue, onCreation]);
+    setActiveItemId(null);
+  };
 
-  const onToggleClick = () => {
-    setIsOpen(!isOpen);
+  const closeMenu = () => {
+    setIsOpen(false);
+    resetActiveAndFocusedItem();
   };
 
-  const onSelect = (_event: React.MouseEvent<Element, MouseEvent> | undefined, value: string | number | undefined) => {
+  const onInputClick = () => {
+    if (!isOpen) {
+      setIsOpen(true);
+    } else if (!inputValue) {
+      closeMenu();
+    }
+  };
+
+  const selectOption = (value: string | number, content: string | number) => {
     // eslint-disable-next-line no-console
+    console.log('selected', content);
+
+    setInputValue(String(content));
+    setFilterValue('');
+    setSelected(String(value));
+
+    closeMenu();
+  };
 
+  const onSelect = (_event: React.MouseEvent<Element, MouseEvent> | undefined, value: string | number | undefined) => {
     if (value) {
-      if (value === 'create') {
-        if (!initialSelectOptions.some((item) => item.value === filterValue)) {
+      if (value === CREATE_NEW) {
+        if (!initialSelectOptions.some((item) => item.children === filterValue)) {
           initialSelectOptions = [...initialSelectOptions, { value: filterValue, children: filterValue }];
         }
         setSelected(filterValue);
-        setOnCreation(!onCreation);
         setFilterValue('');
+        closeMenu();
       } else {
-        // eslint-disable-next-line no-console
-        console.log('selected', value);
-        setInputValue(value as string);
-        setFilterValue('');
-        setSelected(value as string);
+        const optionText = selectOptions.find((option) => option.value === value)?.children;
+        selectOption(value, optionText as string);
       }
     }
-
-    setIsOpen(false);
-    setFocusedItemIndex(null);
-    setActiveItem(null);
   };
 
   const onTextInputChange = (_event: React.FormEvent<HTMLInputElement>, value: string) => {
     setInputValue(value);
     setFilterValue(value);
+
+    resetActiveAndFocusedItem();
+
+    if (value !== selected) {
+      setSelected('');
+    }
   };
 
   const handleMenuArrowKeys = (key: string) => {
-    let indexToFocus;
+    let indexToFocus = 0;
+
+    if (!isOpen) {
+      setIsOpen(true);
+    }
 
-    if (isOpen) {
-      if (key === 'ArrowUp') {
-        // When no index is set or at the first index, focus to the last, otherwise decrement focus index
-        if (focusedItemIndex === null || focusedItemIndex === 0) {
+    if (selectOptions.every((option) => option.isDisabled)) {
+      return;
+    }
+
+    if (key === 'ArrowUp') {
+      // When no index is set or at the first index, focus to the last, otherwise decrement focus index
+      if (focusedItemIndex === null || focusedItemIndex === 0) {
+        indexToFocus = selectOptions.length - 1;
+      } else {
+        indexToFocus = focusedItemIndex - 1;
+      }
+
+      // Skip disabled options
+      while (selectOptions[indexToFocus].isDisabled) {
+        indexToFocus--;
+        if (indexToFocus === -1) {
           indexToFocus = selectOptions.length - 1;
-        } else {
-          indexToFocus = focusedItemIndex - 1;
         }
       }
+    }
+
+    if (key === 'ArrowDown') {
+      // When no index is set or at the last index, focus to the first, otherwise increment focus index
+      if (focusedItemIndex === null || focusedItemIndex === selectOptions.length - 1) {
+        indexToFocus = 0;
+      } else {
+        indexToFocus = focusedItemIndex + 1;
+      }
 
-      if (key === 'ArrowDown') {
-        // When no index is set or at the last index, focus to the first, otherwise increment focus index
-        if (focusedItemIndex === null || focusedItemIndex === selectOptions.length - 1) {
+      // Skip disabled options
+      while (selectOptions[indexToFocus].isDisabled) {
+        indexToFocus++;
+        if (indexToFocus === selectOptions.length) {
           indexToFocus = 0;
-        } else {
-          indexToFocus = focusedItemIndex + 1;
         }
       }
-
-      setFocusedItemIndex(indexToFocus);
-      const focusedItem = selectOptions.filter((option) => !option.isDisabled)[indexToFocus];
-      setActiveItem(`select-create-typeahead-${focusedItem.value.replace(' ', '-')}`);
     }
+
+    setActiveAndFocusedItem(indexToFocus);
   };
 
   const onInputKeyDown = (event: React.KeyboardEvent<HTMLInputElement>) => {
-    const enabledMenuItems = selectOptions.filter((option) => !option.isDisabled);
-    const [firstMenuItem] = enabledMenuItems;
-    const focusedItem = focusedItemIndex ? enabledMenuItems[focusedItemIndex] : firstMenuItem;
+    const focusedItem = focusedItemIndex !== null ? selectOptions[focusedItemIndex] : null;
 
     switch (event.key) {
-      // Select the first available option
       case 'Enter':
-        if (isOpen) {
+        if (isOpen && focusedItem && !focusedItem.isAriaDisabled) {
           onSelect(undefined, focusedItem.value as string);
-          setIsOpen((prevIsOpen) => !prevIsOpen);
-          setFocusedItemIndex(null);
-          setActiveItem(null);
         }
 
-        setIsOpen((prevIsOpen) => !prevIsOpen);
-        setFocusedItemIndex(null);
-        setActiveItem(null);
+        if (!isOpen) {
+          setIsOpen(true);
+        }
 
-        break;
-      case 'Tab':
-      case 'Escape':
-        setIsOpen(false);
-        setActiveItem(null);
         break;
       case 'ArrowUp':
       case 'ArrowDown':
@@ -153,6 +191,19 @@ export const SelectTypeaheadCreatable: React.FunctionComponent = () => {
     }
   };
 
+  const onToggleClick = () => {
+    setIsOpen(!isOpen);
+    textInputRef?.current?.focus();
+  };
+
+  const onClearButtonClick = () => {
+    setSelected('');
+    setInputValue('');
+    setFilterValue('');
+    resetActiveAndFocusedItem();
+    textInputRef?.current?.focus();
+  };
+
   const toggle = (toggleRef: React.Ref<MenuToggleElement>) => (
     <MenuToggle
       ref={toggleRef}
@@ -165,34 +216,23 @@ export const SelectTypeaheadCreatable: React.FunctionComponent = () => {
       <TextInputGroup isPlain>
         <TextInputGroupMain
           value={inputValue}
-          onClick={onToggleClick}
+          onClick={onInputClick}
           onChange={onTextInputChange}
           onKeyDown={onInputKeyDown}
           id="create-typeahead-select-input"
           autoComplete="off"
           innerRef={textInputRef}
           placeholder="Select a state"
-          {...(activeItem && { 'aria-activedescendant': activeItem })}
+          {...(activeItemId && { 'aria-activedescendant': activeItemId })}
           role="combobox"
           isExpanded={isOpen}
           aria-controls="select-create-typeahead-listbox"
         />
 
-        <TextInputGroupUtilities>
-          {!!inputValue && (
-            <Button
-              variant="plain"
-              onClick={() => {
-                setSelected('');
-                setInputValue('');
-                setFilterValue('');
-                textInputRef?.current?.focus();
-              }}
-              aria-label="Clear input value"
-            >
-              <TimesIcon aria-hidden />
-            </Button>
-          )}
+        <TextInputGroupUtilities {...(!inputValue ? { style: { display: 'none' } } : {})}>
+          <Button variant="plain" onClick={onClearButtonClick} aria-label="Clear input value">
+            <TimesIcon aria-hidden />
+          </Button>
         </TextInputGroupUtilities>
       </TextInputGroup>
     </MenuToggle>
@@ -204,10 +244,11 @@ export const SelectTypeaheadCreatable: React.FunctionComponent = () => {
       isOpen={isOpen}
       selected={selected}
       onSelect={onSelect}
-      onOpenChange={() => {
-        setIsOpen(false);
+      onOpenChange={(isOpen) => {
+        !isOpen && closeMenu();
       }}
       toggle={toggle}
+      shouldFocusFirstItemOnOpen={false}
     >
       <SelectList id="select-create-typeahead-listbox">
         {selectOptions.map((option, index) => (
@@ -215,8 +256,7 @@ export const SelectTypeaheadCreatable: React.FunctionComponent = () => {
             key={option.value || option.children}
             isFocused={focusedItemIndex === index}
             className={option.className}
-            onClick={() => setSelected(option.value)}
-            id={`select-typeahead-${option.value.replace(' ', '-')}`}
+            id={createItemId(option.value)}
             {...option}
             ref={null}
           />

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

@@ -14,13 +14,13 @@ const items = [
 ];
 
 const anchors = [
-  <SimpleListItem key="i1" component="a">
+  <SimpleListItem key="i1" component="a" href="#foo">
     Item 1
   </SimpleListItem>,
-  <SimpleListItem key="i2" component="a">
+  <SimpleListItem key="i2" component="a" href="#bar">
     Item 2
   </SimpleListItem>,
-  <SimpleListItem key="i3" component="a">
+  <SimpleListItem key="i3" component="a" href="#baz">
     Item 3
   </SimpleListItem>
 ];

package/src/components/Tabs/Tabs.tsx

@@ -384,6 +384,27 @@ class Tabs extends React.Component<TabsProps, TabsState> {
     this.direction = getLanguageDirection(this.tabList.current);
   }
 
+  static getDerivedStateFromProps(nextProps: TabsProps, prevState: TabsState) {
+    if (prevState.uncontrolledActiveKey === undefined) {
+      return null;
+    }
+
+    const childrenHasTabWithActiveEventKey = React.Children.toArray(nextProps.children)
+      .filter((child): child is TabElement => React.isValidElement(child))
+      .some(({ props }) => props.eventKey === prevState.uncontrolledActiveKey);
+
+    // if uncontrolledActiveKey is an existing eventKey of any Tab of nextProps.children --> don't update uncontrolledActiveKey
+    if (childrenHasTabWithActiveEventKey) {
+      return null;
+    }
+
+    // otherwise update state derived from nextProps.defaultActiveKey
+    return {
+      uncontrolledActiveKey: nextProps.defaultActiveKey,
+      shownKeys: nextProps.defaultActiveKey !== undefined ? [nextProps.defaultActiveKey] : [nextProps.activeKey] // only for mountOnEnter case
+    };
+  }
+
   render() {
     const {
       className,

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

@@ -5,7 +5,7 @@ import userEvent from '@testing-library/user-event';
 
 import { TextInput, TextInputBase } from '../TextInput';
 import { ValidatedOptions } from '../../../helpers/constants';
-import * as ReactCoreUtils from '@patternfly/react-core/src/helpers/util';
+import * as ReactCoreUtils from '../../../helpers/util';
 
 const props = {
   onChange: jest.fn(),

package/src/components/ToggleGroup/examples/ToggleGroup.md

@@ -13,22 +13,47 @@ import ShareSquareIcon from '@patternfly/react-icons/dist/esm/icons/share-square
 
 ## Examples
 
-### Default with multiple selectable
-```ts file="./ToggleGroupDefaultMultiple.tsx"
-```
+### Single select toggle group
+
+A single select toggle group allows users to toggle between multiple items.
+
+To indicate whether a `<ToggleGroupItem>` is selected or not, use the `isSelected` property.
 
-### Default with single selectable
 ```ts file="./ToggleGroupDefaultSingle.tsx"
 ```
 
-### Icons
+### Multi select toggle group
+
+A multi select toggle group allows users to select multiple items at once.
+
+When a toggle item is disabled it cannot be selected. Click the "Disable all" button in the following example to see this in action.
+
+```ts file="./ToggleGroupDefaultMultiple.tsx"
+```
+
+### With icons
+
+You can use a recognizable icon as a toggle item label.
+
+To do this, pass an imported icon to the `icon` property of a `<ToggleGroupItem>`.
+
 ```ts file="./ToggleGroupIcon.tsx"
 ```
 
-### Text and icons
+### With text and icons
+
+Adding text to a toggle item with an icon helps clarify the button's function.
+
+To do this, pass a descriptive label to the `text` property of a `<ToggleGroupItem>`.
+
 ```ts file="./ToggleGroupTextIcon.tsx"
 ```
 
-### Compact variant
+### Compact toggle group
+
+When space in a UI is limited, you can use a compact toggle group. 
+
+To apply compact styling to a `<ToggleGroup>`, use `isCompact`.
+
 ```ts file="./ToggleGroupCompact.tsx"
-```
+```

package/src/components/TreeView/TreeView.tsx

@@ -46,6 +46,14 @@ export interface TreeViewProps {
    * internal state.
    */
   allExpanded?: boolean;
+  /** A text string that sets the accessible name of the tree view list. Either this or the aria-labelledby property must
+   * be passed in.
+   */
+  'aria-label'?: string;
+  /** A space separated list of element id's that sets the accessible name of the tree view list. Either
+   * this or the aria-label property must be passed in.
+   */
+  'aria-labelledby'?: string;
   /** Class to add if not passed a parentItem property. */
   className?: string;
   /** Comparison function for determining active items. */
@@ -72,6 +80,11 @@ export interface TreeViewProps {
   icon?: React.ReactNode;
   /** ID of the tree view. */
   id?: string;
+  /** Flag indicating whether multiple nodes can be selected in the tree view. This will also set the
+   * aria-multiselectable attribute on the tree view list which is required to be true when multiple selection is intended.
+   * Can only be applied to the root tree view list.
+   */
+  isMultiSelectable?: boolean;
   /** Callback for item checkbox selection. */
   onCheck?: (event: React.ChangeEvent<HTMLInputElement>, item: TreeViewDataItem, parentItem: TreeViewDataItem) => void;
   /** Callback for item selection. */
@@ -104,6 +117,7 @@ export const TreeView: React.FunctionComponent<TreeViewProps> = ({
   defaultAllExpanded = false,
   allExpanded,
   icon,
+  isMultiSelectable = false,
   expandedIcon,
   parentItem,
   onSelect,
@@ -115,10 +129,18 @@ export const TreeView: React.FunctionComponent<TreeViewProps> = ({
   compareItems = (item, itemToCheck) => item.id === itemToCheck.id,
   className,
   useMemo,
+  'aria-label': ariaLabel,
+  'aria-labelledby': ariaLabelledby,
   ...props
 }: TreeViewProps) => {
   const treeViewList = (
-    <TreeViewList isNested={isNested} toolbar={toolbar}>
+    <TreeViewList
+      isNested={isNested}
+      toolbar={toolbar}
+      isMultiSelectable={isMultiSelectable}
+      aria-label={ariaLabel}
+      aria-labelledby={ariaLabelledby}
+    >
       {data.map((item) => (
         <TreeViewListItem
           key={item.id?.toString() || item.name?.toString()}

package/src/components/TreeView/TreeViewList.tsx

@@ -10,12 +10,28 @@ export interface TreeViewListProps extends React.HTMLProps<HTMLUListElement> {
   isNested?: boolean;
   /** Toolbar to display above the tree view. */
   toolbar?: React.ReactNode;
+  /** Flag indicating whether multiple nodes can be selected in the tree view. This will also set the
+   * aria-multiselectable attribute on the tree view list which is required to be true when multiple selection is intended.
+   * Can only be applied to the root tree view list.
+   */
+  isMultiSelectable?: boolean;
+  /** A text string that sets the accessible name of the tree view list. Either this or the aria-labelledby property must
+   * be passed in.
+   */
+  'aria-label'?: string;
+  /** A space separated list of element id's that sets the accessible name of the tree view list. Either
+   * this or the aria-label property must be passed in.
+   */
+  'aria-labelledby'?: string;
 }
 
 export const TreeViewList: React.FunctionComponent<TreeViewListProps> = ({
   isNested = false,
+  isMultiSelectable = false,
   toolbar,
   children,
+  'aria-label': ariaLabel,
+  'aria-labelledby': ariaLabelledby,
   ...props
 }: TreeViewListProps) => (
   <>
@@ -25,7 +41,14 @@ export const TreeViewList: React.FunctionComponent<TreeViewListProps> = ({
         <Divider />
       </React.Fragment>
     )}
-    <ul className={css(`${styles.treeView}__list`)} role={isNested ? 'group' : 'tree'} {...props}>
+    <ul
+      className={css(`${styles.treeView}__list`)}
+      role={isNested ? 'group' : 'tree'}
+      aria-multiselectable={isNested ? undefined : isMultiSelectable}
+      aria-label={ariaLabel}
+      aria-labelledby={ariaLabelledby}
+      {...props}
+    >
       {children}
     </ul>
   </>

package/src/components/TreeView/TreeViewListItem.tsx

@@ -143,6 +143,8 @@ const TreeViewListItemBase: React.FunctionComponent<TreeViewListItemProps> = ({
       </span>
     </ToggleComponent>
   );
+
+  const isCheckboxChecked = checkProps.checked === null ? false : checkProps.checked;
   const renderCheck = (randomId: string) => (
     <span className={css(styles.treeViewNodeCheck)}>
       <input
@@ -151,7 +153,7 @@ const TreeViewListItemBase: React.FunctionComponent<TreeViewListItemProps> = ({
         onClick={(evt) => evt.stopPropagation()}
         ref={(elem) => elem && (elem.indeterminate = checkProps.checked === null)}
         {...checkProps}
-        checked={checkProps.checked === null ? false : checkProps.checked}
+        checked={isCheckboxChecked}
         id={randomId}
         tabIndex={-1}
       />
@@ -194,6 +196,13 @@ const TreeViewListItemBase: React.FunctionComponent<TreeViewListItemProps> = ({
       )}
     </>
   );
+
+  const isSelected =
+    (!children || isSelectable) &&
+    activeItems &&
+    activeItems.length > 0 &&
+    activeItems.some((item) => compareItems && item && compareItems(item, itemData));
+
   return (
     <li
       id={id}
@@ -201,6 +210,8 @@ const TreeViewListItemBase: React.FunctionComponent<TreeViewListItemProps> = ({
       aria-expanded={internalIsExpanded}
       role="treeitem"
       tabIndex={-1}
+      {...(hasCheckbox && { 'aria-checked': isCheckboxChecked })}
+      {...(!hasCheckbox && { 'aria-selected': isSelected })}
     >
       <div className={css(styles.treeViewContent)}>
         <GenerateId prefix={isSelectable ? 'selectable-id' : 'checkbox-id'}>
@@ -209,12 +220,7 @@ const TreeViewListItemBase: React.FunctionComponent<TreeViewListItemProps> = ({
               className={css(
                 styles.treeViewNode,
                 children && (isSelectable || hasCheckbox) && styles.modifiers.selectable,
-                (!children || isSelectable) &&
-                  activeItems &&
-                  activeItems.length > 0 &&
-                  activeItems.some((item) => compareItems && item && compareItems(item, itemData))
-                  ? styles.modifiers.current
-                  : ''
+                isSelected && styles.modifiers.current
               )}
               onClick={(evt: React.MouseEvent) => {
                 if (!hasCheckbox) {

package/src/components/TreeView/__tests__/__snapshots__/TreeViewList.test.tsx.snap

@@ -3,6 +3,7 @@
 exports[`Matches snapshot by default 1`] = `
 <DocumentFragment>
   <ul
+    aria-multiselectable="false"
     class="pf-v5-c-tree-view__list"
     role="tree"
   >
@@ -20,6 +21,7 @@ exports[`Matches snapshot when toolbar is passed 1`] = `
     class="pf-v5-c-divider"
   />
   <ul
+    aria-multiselectable="false"
     class="pf-v5-c-tree-view__list"
     role="tree"
   >

package/src/components/TreeView/__tests__/__snapshots__/TreeViewListItem.test.tsx.snap

@@ -4,6 +4,7 @@ exports[`Matches snapshot with children 1`] = `
 <DocumentFragment>
   <li
     aria-expanded="false"
+    aria-selected="false"
     class="pf-v5-c-tree-view__list-item"
     role="treeitem"
     tabindex="-1"
@@ -56,6 +57,7 @@ exports[`Matches snapshot without children 1`] = `
 <DocumentFragment>
   <li
     aria-expanded="false"
+    aria-selected="false"
     class="pf-v5-c-tree-view__list-item"
     role="treeitem"
     tabindex="-1"

package/src/components/TreeView/examples/TreeView.md

@@ -9,9 +9,17 @@ import { FolderIcon, FolderOpenIcon, EllipsisVIcon, ClipboardIcon, HamburgerIcon
 
 ## Examples
 
-### Default
+### Single selectable
 
-```ts file='./TreeViewDefault.tsx'
+```ts file='./TreeViewSingleSelectable.tsx'
+
+```
+
+### Multiselectable
+
+A tree view can be setup to allow multiple nodes to be selected. When a tree view is intended to allow multiple selection, the `isMultiSelectable` property must be passed.
+
+```ts file='./TreeViewMultiselectable.tsx'
 
 ```
 
@@ -25,6 +33,8 @@ The `hasSelectableNodes` modifier will separate the expansion and selection beha
 
 ### With search
 
+A search input can be used to filter tree view items. It is recommended that a tree view with more than 7 nodes includes a search input.
+
 ```ts file='./TreeViewWithSearch.tsx'
 
 ```

package/src/components/TreeView/examples/TreeViewCompact.tsx

@@ -55,5 +55,5 @@ export const TreeViewCompact: React.FunctionComponent = () => {
       ]
     }
   ];
-  return <TreeView data={options} variant="compact" />;
+  return <TreeView aria-label="Tree View compact example" data={options} variant="compact" />;
 };

package/src/components/TreeView/examples/TreeViewCompactNoBackground.tsx

@@ -55,5 +55,5 @@ export const TreeViewCompactNoBackground: React.FunctionComponent = () => {
       ]
     }
   ];
-  return <TreeView data={options} variant="compactNoBackground" />;
+  return <TreeView aria-label="Tree View compact no background example" data={options} variant="compactNoBackground" />;
 };

package/src/components/TreeView/examples/TreeViewGuides.tsx

@@ -61,5 +61,5 @@ export const GuidesTreeView: React.FunctionComponent = () => {
       children: [{ name: 'Application 5', id: 'example8-App5' }]
     }
   ];
-  return <TreeView data={options} hasGuides={true} />;
+  return <TreeView aria-label="Tree View guides example" data={options} hasGuides={true} />;
 };