@coreui/react-pro 5.25.0 → 5.27.0

package/src/components/modal/CModalHeader.tsx

@@ -6,6 +6,12 @@ import { CCloseButton } from '../close-button/CCloseButton'
 import { CModalContext } from './CModalContext'
 
 export interface CModalHeaderProps extends HTMLAttributes<HTMLDivElement> {
+  /**
+   * Sets the `aria-label` of the close button.
+   *
+   * @since 5.13.0
+   */
+  ariaCloseLabel?: string
   /**
    * A string of all className you want applied to the base component.
    */
@@ -17,19 +23,22 @@ export interface CModalHeaderProps extends HTMLAttributes<HTMLDivElement> {
 }
 
 export const CModalHeader = forwardRef<HTMLDivElement, CModalHeaderProps>(
-  ({ children, className, closeButton = true, ...rest }, ref) => {
+  ({ children, ariaCloseLabel, className, closeButton = true, ...rest }, ref) => {
     const { setVisible } = useContext(CModalContext)
 
     return (
       <div className={classNames('modal-header', className)} {...rest} ref={ref}>
         {children}
-        {closeButton && <CCloseButton onClick={() => setVisible(false)} />}
+        {closeButton && (
+          <CCloseButton aria-label={ariaCloseLabel} onClick={() => setVisible(false)} />
+        )}
       </div>
     )
   }
 )
 
 CModalHeader.propTypes = {
+  ariaCloseLabel: PropTypes.string,
   children: PropTypes.node,
   className: PropTypes.string,
   closeButton: PropTypes.bool,

package/src/components/multi-select/CMultiSelect.tsx

@@ -30,10 +30,18 @@ import {
   isGlobalSearch,
   selectOptions,
 } from './utils'
-import type { Option, OptionsGroup, Search, SelectedOption } from './types'
+import type {
+  Option,
+  OptionsGroup,
+  Search,
+  SelectedOption,
+  SelectionActions,
+  SelectionState,
+} from './types'
 
 export interface CMultiSelectProps
-  extends Omit<CFormControlWrapperProps, 'floatingClassName' | 'floatingLabel'>,
+  extends
+    Omit<CFormControlWrapperProps, 'floatingClassName' | 'floatingLabel'>,
     Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
   /**
    * Allow users to create options if they are not in the list of options.
@@ -53,6 +61,18 @@ export interface CMultiSelectProps
    * @since 5.19.0
    */
   ariaIndicatorLabel?: string
+  /**
+   * Accessible label for the search input (when `search` is enabled).
+   *
+   * @since 5.26.0
+   */
+  ariaSearchLabel?: string
+  /**
+   * Accessible label prefix for a tag's delete button (selection type `tags`). The selected option's label is appended, so screen readers announce e.g. "Remove Angular".
+   *
+   * @since 5.26.0
+   */
+  ariaTagDeleteLabel?: string
   /**
    * A string of all className you want applied to the base component.
    */
@@ -77,6 +97,18 @@ export interface CMultiSelectProps
    * Toggle the disabled state for the component.
    */
   disabled?: boolean
+  /**
+   * Render a custom dropdown header (the area above the options list), replacing the built-in select all button. Receives a `state` object (`{ selected, total, filtered, filteredSelected }`) and an `actions` object (`{ selectAll, deselectAll, selectFiltered, deselectFiltered }`) so you can wire your own controls. Renders independently of `selectAll`.
+   *
+   * @since 5.26.0
+   */
+  headerTemplate?: (state: SelectionState, actions: SelectionActions) => ReactNode
+  /**
+   * Hide the dropdown header with the built-in select all button when a search filter leaves no matching options. Set to `false` to keep the select all button visible even when there are no results.
+   *
+   * @since 5.27.0
+   */
+  hideSelectAllOnSearchNoResults?: boolean
   /**
    * Set the id attribute for the native select element.
    *
@@ -114,6 +146,12 @@ export interface CMultiSelectProps
    * The callback is fired when the Multi Select component requests to be hidden.
    */
   onHide?: () => void
+  /**
+   * Execute a function when the user tries to select more options than allowed by `selectionLimit`.
+   *
+   * @since 5.26.0
+   */
+  onSelectionLimit?: (selectionLimit: number) => void
   /**
    * The callback is fired when the Multi Select component requests to be shown.
    */
@@ -136,6 +174,18 @@ export interface CMultiSelectProps
    * @since 4.12.0
    */
   optionsTemplate?: (option: Option) => ReactNode
+  /**
+   * Makes each options group label a toggle that selects or deselects all options in that group. With `optionsGroupsStyle="checkbox"` (and `multiple`) the label shows a tri-state checkbox indicator (`none` / `all` / `indeterminate`) reflecting the group's selection.
+   *
+   * @since 5.26.0
+   */
+  optionsGroupsSelectable?: boolean
+  /**
+   * Sets the options group label style when `optionsGroupsSelectable` is enabled.
+   *
+   * @since 5.26.0
+   */
+  optionsGroupsStyle?: 'checkbox' | 'text'
   /**
    * Custom template for options groups.
    *
@@ -175,6 +225,18 @@ export interface CMultiSelectProps
    * Sets the label for no results when filtering.
    */
   searchNoResultsLabel?: string | ReactNode
+  /**
+   * Sets the select all button label shown once everything is selected. The button is a toggle: it shows `selectAllLabel` (and selects all) until everything is selected, then shows `deselectAllLabel` (and deselects all).
+   *
+   * @since 5.26.0
+   */
+  deselectAllLabel?: string | ReactNode
+  /**
+   * Sets the deselect filtered button label (selection type `selectAllMode="filtered"`).
+   *
+   * @since 5.26.0
+   */
+  deselectFilteredLabel?: string | ReactNode
   /**
    * Enables select all button.
    */
@@ -183,6 +245,30 @@ export interface CMultiSelectProps
    * Sets the select all button label.
    */
   selectAllLabel?: string | ReactNode
+  /**
+   * Determines what the select all button operates on: all options (`'all'`) or only the currently filtered (search-visible) options (`'filtered'`).
+   *
+   * @since 5.26.0
+   */
+  selectAllMode?: 'all' | 'filtered'
+  /**
+   * Sets the select all button style. With `'checkbox'` (and `multiple`), the button shows a tri-state checkbox indicator (`none` / `all` / `indeterminate`) and toggles between selecting and deselecting.
+   *
+   * @since 5.26.0
+   */
+  selectAllStyle?: 'checkbox' | 'text'
+  /**
+   * Sets the select filtered button label (used with `selectAllMode="filtered"`).
+   *
+   * @since 5.26.0
+   */
+  selectFilteredLabel?: string | ReactNode
+  /**
+   * Sets the maximum number of options that can be selected. The select all button stays enabled and selects options up to the limit, then toggles to deselect all once the limit is reached. The `onSelectionLimit` callback fires when a user tries to select more options than allowed.
+   *
+   * @since 5.26.0
+   */
+  selectionLimit?: number
   /**
    * Sets the selection style.
    */
@@ -225,14 +311,20 @@ export const CMultiSelect = forwardRef<HTMLDivElement, CMultiSelectProps>(
       allowCreateOptions,
       ariaCleanerLabel = 'Clear all selections',
       ariaIndicatorLabel = 'Toggle visibility of options menu',
+      ariaSearchLabel = 'Search',
+      ariaTagDeleteLabel = 'Remove',
       className,
       cleaner = true,
       clearSearchOnSelect,
       container,
+      deselectAllLabel = 'Deselect all',
+      deselectFilteredLabel = 'Deselect filtered',
       disabled,
       feedback,
       feedbackInvalid,
       feedbackValid,
+      headerTemplate,
+      hideSelectAllOnSearchNoResults = true,
       id,
       invalid,
       label,
@@ -242,11 +334,14 @@ export const CMultiSelect = forwardRef<HTMLDivElement, CMultiSelectProps>(
       onChange,
       onFilterChange,
       onHide,
+      onSelectionLimit,
       onShow,
       options,
       optionsMaxHeight = 'auto',
       optionsStyle = 'checkbox',
       optionsTemplate,
+      optionsGroupsSelectable = false,
+      optionsGroupsStyle = 'checkbox',
       optionsGroupsTemplate,
       placeholder = 'Select...',
       portal = false,
@@ -255,7 +350,11 @@ export const CMultiSelect = forwardRef<HTMLDivElement, CMultiSelectProps>(
       search = true,
       searchNoResultsLabel = 'No results found',
       selectAll = true,
-      selectAllLabel = 'Select all options',
+      selectAllLabel = 'Select all',
+      selectAllMode = 'all',
+      selectAllStyle = 'checkbox',
+      selectFilteredLabel = 'Select filtered',
+      selectionLimit,
       selectionType = 'tags',
       selectionTypeCounterText = 'item(s) selected',
       size,
@@ -288,20 +387,26 @@ export const CMultiSelect = forwardRef<HTMLDivElement, CMultiSelectProps>(
     const [selected, setSelected] = useState<SelectedOption[]>([])
     const [userOptions, setUserOptions] = useState<Option[]>([])
 
-    const filteredOptions = useMemo(
-      () =>
-        flattenOptionsArray(
-          isExternalSearch(search)
-            ? [...options, ...filterOptionsList(searchValue, userOptions)]
-            : filterOptionsList(searchValue, [...options, ...userOptions]),
-          true
-        ),
-      [options, searchValue, userOptions]
-    )
+    const filteredOptions = useMemo(() => {
+      const source = isExternalSearch(search)
+        ? [...options, ...filterOptionsList(searchValue, userOptions)]
+        : filterOptionsList(searchValue, [...options, ...userOptions])
+
+      const flattened: (Option | OptionsGroup)[] = []
+      for (const option of source) {
+        if (Array.isArray((option as OptionsGroup).options)) {
+          flattened.push(option, ...((option as OptionsGroup).options as Option[]))
+        } else {
+          flattened.push(option)
+        }
+      }
+
+      return flattened
+    }, [options, searchValue, userOptions])
 
     const flattenedOptions = useMemo(
       () =>
-        flattenOptionsArray(options).map((option) => {
+        (flattenOptionsArray(options) as Option[]).map((option) => {
           if (value && Array.isArray(value)) {
             return {
               ...option,
@@ -334,15 +439,101 @@ export const CMultiSelect = forwardRef<HTMLDivElement, CMultiSelectProps>(
       return searchRef.current && createOption(String(searchValue), flattenedOptions)
     }, [filteredOptions, searchValue])
 
+    const dropdownOptions =
+      filteredOptions.length === 0 && allowCreateOptions ? userOption || [] : filteredOptions
+
+    const selectableOptions = useMemo(
+      () =>
+        flattenOptionsArray([...options, ...userOptions]).filter(
+          (option): option is Option => !option.disabled
+        ),
+      [options, userOptions]
+    )
+
+    const filteredSelectableOptions = useMemo(
+      () =>
+        flattenOptionsArray(
+          isExternalSearch(search)
+            ? [...options, ...filterOptionsList(searchValue, userOptions)]
+            : filterOptionsList(searchValue, [...options, ...userOptions])
+        ).filter((option): option is Option => !option.disabled),
+      [options, searchValue, userOptions]
+    )
+
+    const selectedValues = new Set(selected.map((option) => option.value))
+    const countSelected = (scope: Option[]) =>
+      scope.filter((option) => selectedValues.has(option.value)).length
+
+    const hasSelectionLimit = multiple && typeof selectionLimit === 'number'
+    const isSelectionLimitReached =
+      hasSelectionLimit && selected.length >= (selectionLimit as number)
+    const selectableTarget = (total: number) =>
+      hasSelectionLimit ? Math.min(total, selectionLimit as number) : total
+
+    const selectWithLimit = (scope: Option[]) => {
+      if (!hasSelectionLimit) {
+        setSelected(selectOptions(multiple, scope, selected))
+        return
+      }
+
+      const remaining = (selectionLimit as number) - selected.length
+
+      if (remaining <= 0) {
+        onSelectionLimit?.(selectionLimit as number)
+        return
+      }
+
+      const toAdd = scope.filter((option) => !selectedValues.has(option.value))
+      setSelected(selectOptions(multiple, toAdd.slice(0, remaining), selected))
+
+      if (toAdd.length > remaining) {
+        onSelectionLimit?.(selectionLimit as number)
+      }
+    }
+
+    const selectAllScope =
+      selectAllMode === 'filtered'
+        ? {
+            selected: countSelected(filteredSelectableOptions),
+            total: filteredSelectableOptions.length,
+          }
+        : { selected: countSelected(selectableOptions), total: selectableOptions.length }
+
+    const selectAllTarget = selectableTarget(selectAllScope.total)
+    const isAllSelected = selectAllTarget > 0 && selectAllScope.selected >= selectAllTarget
+    const selectAllCheckboxState = isAllSelected
+      ? 'all'
+      : selectAllScope.selected === 0
+        ? 'none'
+        : 'indeterminate'
+    const isFilteredScopeNarrowed =
+      selectAllMode === 'filtered' && filteredSelectableOptions.length < selectableOptions.length
+    const selectAllButtonLabel = isFilteredScopeNarrowed
+      ? isAllSelected
+        ? deselectFilteredLabel
+        : selectFilteredLabel
+      : isAllSelected
+        ? deselectAllLabel
+        : selectAllLabel
+
+    const headerState: SelectionState = {
+      selected: selected.length,
+      total: selectableOptions.length,
+      filtered: filteredSelectableOptions.length,
+      filteredSelected: countSelected(filteredSelectableOptions),
+    }
+
     useEffect(() => {
       if (!isInitialMount.current && resetSelectionOnOptionsChange) {
         return setSelected([])
       }
 
-      const _selected = flattenedOptions.filter((option: Option) => option.selected === true)
+      const _selected = flattenedOptions.filter(
+        (option): option is Option => option.selected === true
+      )
       const deselected = flattenedOptions.filter(
-        (option: Option) => option.selected === false
-      ) as Option[]
+        (option): option is Option => option.selected === false
+      )
 
       if (_selected.length > 0 || deselected.length > 0) {
         setSelected(selectOptions(multiple, _selected, selected, deselected))
@@ -381,6 +572,20 @@ export const CMultiSelect = forwardRef<HTMLDivElement, CMultiSelectProps>(
       return () => {
         if (onHide) onHide()
 
+        if (isOpen) {
+          const active = document.activeElement
+          const menu = dropdownMenuElement.current as HTMLElement | null
+          const toggler = dropdownRefElement.current as HTMLElement | null
+
+          if (menu?.contains(active) || toggler?.contains(active)) {
+            if (search && searchRef.current) {
+              searchRef.current.focus()
+            } else {
+              toggler?.focus()
+            }
+          }
+        }
+
         setSearchValue('')
         if (searchRef.current) {
           searchRef.current.value = ''
@@ -454,7 +659,7 @@ export const CMultiSelect = forwardRef<HTMLDivElement, CMultiSelectProps>(
       }
 
       if (event.key === 'Backspace' || event.key === 'Delete') {
-        const last = selected.filter((option: Option) => !option.disabled).pop()
+        const last = selected.findLast((option: Option) => !option.disabled)
 
         if (last) {
           setSelected(selected.filter((option: Option) => option.value !== last.value))
@@ -483,6 +688,36 @@ export const CMultiSelect = forwardRef<HTMLDivElement, CMultiSelectProps>(
       }
     }
 
+    const handleNativeSelectKeyDown = (event: React.KeyboardEvent<HTMLSelectElement>) => {
+      if (event.key === 'Tab' || event.key === 'Escape') {
+        return
+      }
+
+      event.preventDefault()
+
+      const isPrintable =
+        event.key.length === 1 && !event.ctrlKey && !event.metaKey && !event.altKey
+
+      if (
+        !isOpen &&
+        (event.key === 'Enter' || event.key === 'ArrowDown' || (search && isPrintable))
+      ) {
+        openDropdown()
+      }
+
+      if (search && searchRef.current) {
+        searchRef.current.focus()
+
+        if (isPrintable) {
+          const nextValue = searchRef.current.value + event.key
+          searchRef.current.value = nextValue
+          setSearchValue(nextValue)
+        }
+      } else {
+        ;(dropdownRefElement.current as HTMLElement | null)?.focus()
+      }
+    }
+
     const handleGlobalSearch = (event: React.KeyboardEvent<HTMLDivElement>) => {
       if (
         isGlobalSearch(search) &&
@@ -505,6 +740,13 @@ export const CMultiSelect = forwardRef<HTMLDivElement, CMultiSelectProps>(
         return
       }
 
+      const alreadySelected = selected.some((_option) => _option.value === option.value)
+
+      if (!alreadySelected && isSelectionLimitReached) {
+        onSelectionLimit?.(selectionLimit as number)
+        return
+      }
+
       if (option.custom && !userOptions.some((_option) => _option.value === option.value)) {
         setUserOptions([...userOptions, option])
       }
@@ -517,7 +759,7 @@ export const CMultiSelect = forwardRef<HTMLDivElement, CMultiSelectProps>(
         }
       }
 
-      if (selected.some((_option) => _option.value === option.value)) {
+      if (alreadySelected) {
         setSelected(selected.filter((_option) => _option.value !== option.value))
       } else {
         setSelected([...selected, option] as SelectedOption[])
@@ -525,19 +767,50 @@ export const CMultiSelect = forwardRef<HTMLDivElement, CMultiSelectProps>(
     }
 
     const handleSelectAll = () => {
-      setSelected(
-        selectOptions(
-          multiple,
-          [...flattenedOptions.filter((option: Option) => !option.disabled), ...userOptions],
-          selected
-        )
-      )
+      selectWithLimit(selectableOptions)
     }
 
     const handleDeselectAll = () => {
       setSelected(selected.filter((option) => option.disabled))
     }
 
+    const handleSelectFiltered = () => {
+      selectWithLimit(filteredSelectableOptions)
+    }
+
+    const handleDeselectFiltered = () => {
+      const filteredValues = new Set(filteredSelectableOptions.map((option) => option.value))
+      setSelected(selected.filter((option) => option.disabled || !filteredValues.has(option.value)))
+    }
+
+    const handleSelectAllToggle = () => {
+      if (selectAllMode === 'filtered') {
+        isAllSelected ? handleDeselectFiltered() : handleSelectFiltered()
+      } else {
+        isAllSelected ? handleDeselectAll() : handleSelectAll()
+      }
+    }
+
+    const handleGroupClick = (group: OptionsGroup) => {
+      const groupOptions = (group.options ?? []).filter((option) => !option.disabled)
+      const allSelected =
+        groupOptions.length > 0 && groupOptions.every((option) => selectedValues.has(option.value))
+
+      if (allSelected) {
+        const groupValues = new Set(groupOptions.map((option) => option.value))
+        setSelected(selected.filter((option) => option.disabled || !groupValues.has(option.value)))
+      } else {
+        selectWithLimit(groupOptions)
+      }
+    }
+
+    const headerActions: SelectionActions = {
+      selectAll: handleSelectAll,
+      deselectAll: handleDeselectAll,
+      selectFiltered: handleSelectFiltered,
+      deselectFiltered: handleDeselectFiltered,
+    }
+
     return (
       <CFormControlWrapper
         describedby={rest['aria-describedby']}
@@ -551,20 +824,6 @@ export const CMultiSelect = forwardRef<HTMLDivElement, CMultiSelectProps>(
         tooltipFeedback={tooltipFeedback}
         valid={valid}
       >
-        <CMultiSelectNativeSelect
-          id={id ?? uniqueId}
-          multiple={multiple}
-          name={name ?? uniqueId}
-          options={selected}
-          required={required}
-          value={
-            multiple
-              ? selected.map((option: SelectedOption) => option.value.toString())
-              : selected.map((option: SelectedOption) => option.value)[0]
-          }
-          onChange={() => onChange && onChange(selected)}
-          ref={nativeSelectRef}
-        />
         <div
           className={classNames(
             'form-multi-select',
@@ -578,9 +837,23 @@ export const CMultiSelect = forwardRef<HTMLDivElement, CMultiSelectProps>(
             className
           )}
           onKeyDown={handleGlobalSearch}
-          aria-expanded={isOpen}
           ref={ref}
         >
+          <CMultiSelectNativeSelect
+            id={id ?? uniqueId}
+            multiple={multiple}
+            name={name ?? uniqueId}
+            options={selected}
+            required={required}
+            value={
+              multiple
+                ? selected.map((option: SelectedOption) => option.value.toString())
+                : selected.map((option: SelectedOption) => option.value)[0]
+            }
+            onChange={() => onChange && onChange(selected)}
+            onKeyDown={handleNativeSelectKeyDown}
+            ref={nativeSelectRef}
+          />
           <div
             className="form-multi-select-input-group"
             {...(!search && !disabled && { tabIndex: 0 })}
@@ -589,10 +862,13 @@ export const CMultiSelect = forwardRef<HTMLDivElement, CMultiSelectProps>(
             role="combobox"
             aria-haspopup="listbox"
             aria-expanded={isOpen}
+            aria-controls={`multiselect-listbox-${uniqueId}`}
             {...(portal && { 'aria-owns': `multiselect-listbox-${uniqueId}` })}
+            {...(disabled && { 'aria-disabled': true })}
             ref={dropdownRefElement}
           >
             <CMultiSelectSelection
+              ariaTagDeleteLabel={ariaTagDeleteLabel}
               disabled={disabled}
               multiple={multiple}
               onRemove={(option) => !disabled && handleOnOptionClick(option)}
@@ -610,6 +886,9 @@ export const CMultiSelect = forwardRef<HTMLDivElement, CMultiSelectProps>(
                   id={`search${id ?? uniqueId}`}
                   name={`search${name ?? uniqueId}`}
                   autoComplete="off"
+                  aria-label={ariaSearchLabel}
+                  aria-autocomplete="list"
+                  aria-controls={`multiselect-listbox-${uniqueId}`}
                   onChange={handleSearchChange}
                   onKeyDown={handleSearchKeyDown}
                   {...(selected.length === 0 && { placeholder: placeholder })}
@@ -665,23 +944,44 @@ export const CMultiSelect = forwardRef<HTMLDivElement, CMultiSelectProps>(
               aria-multiselectable={multiple}
               ref={dropdownMenuElement}
             >
-              {multiple && selectAll && (
-                <button
-                  type="button"
-                  className="form-multi-select-all"
-                  onClick={() => handleSelectAll()}
-                >
-                  {selectAllLabel}
-                </button>
+              {(headerTemplate ||
+                (multiple &&
+                  selectAll &&
+                  !(
+                    hideSelectAllOnSearchNoResults &&
+                    searchValue.length > 0 &&
+                    dropdownOptions.length === 0
+                  ))) && (
+                <div className="form-multi-select-dropdown-header">
+                  {headerTemplate ? (
+                    <div onClick={(event) => event.stopPropagation()}>
+                      {headerTemplate(headerState, headerActions)}
+                    </div>
+                  ) : (
+                    <button
+                      type="button"
+                      className={classNames('form-multi-select-all', {
+                        'form-multi-select-all-with-checkbox': selectAllStyle === 'checkbox',
+                        'form-multi-selected':
+                          selectAllStyle === 'checkbox' && selectAllCheckboxState === 'all',
+                        'form-multi-select-indeterminate':
+                          selectAllStyle === 'checkbox' &&
+                          selectAllCheckboxState === 'indeterminate',
+                      })}
+                      onClick={() => handleSelectAllToggle()}
+                    >
+                      {selectAllButtonLabel}
+                    </button>
+                  )}
+                </div>
               )}
               <CMultiSelectOptions
                 loading={loading}
+                onGroupOnClick={(group) => !disabled && handleGroupClick(group)}
                 onOptionOnClick={(option) => !disabled && handleOnOptionClick(option)}
-                options={
-                  filteredOptions.length === 0 && allowCreateOptions
-                    ? userOption || []
-                    : filteredOptions
-                }
+                options={dropdownOptions}
+                optionsGroupsSelectable={optionsGroupsSelectable && multiple}
+                optionsGroupsStyle={optionsGroupsStyle}
                 optionsMaxHeight={optionsMaxHeight}
                 optionsStyle={optionsStyle}
                 optionsTemplate={optionsTemplate}
@@ -703,22 +1003,31 @@ CMultiSelect.propTypes = {
   allowCreateOptions: PropTypes.bool,
   ariaCleanerLabel: PropTypes.string,
   ariaIndicatorLabel: PropTypes.string,
+  ariaSearchLabel: PropTypes.string,
+  ariaTagDeleteLabel: PropTypes.string,
   className: PropTypes.string,
   cleaner: PropTypes.bool,
   clearSearchOnSelect: PropTypes.bool,
   container: PropTypes.any,
+  deselectAllLabel: PropTypes.oneOfType([PropTypes.string, PropTypes.node]),
+  deselectFilteredLabel: PropTypes.oneOfType([PropTypes.string, PropTypes.node]),
   disabled: PropTypes.bool,
+  headerTemplate: PropTypes.func,
+  hideSelectAllOnSearchNoResults: PropTypes.bool,
   loading: PropTypes.bool,
   multiple: PropTypes.bool,
   name: PropTypes.string,
   onChange: PropTypes.func,
   onFilterChange: PropTypes.func,
   onHide: PropTypes.func,
+  onSelectionLimit: PropTypes.func,
   onShow: PropTypes.func,
   options: PropTypes.array.isRequired,
   optionsMaxHeight: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
   optionsStyle: PropTypes.oneOf(['checkbox', 'text']),
   optionsTemplate: PropTypes.func,
+  optionsGroupsSelectable: PropTypes.bool,
+  optionsGroupsStyle: PropTypes.oneOf(['checkbox', 'text']),
   optionsGroupsTemplate: PropTypes.func,
   placeholder: PropTypes.string,
   portal: PropTypes.bool,
@@ -735,6 +1044,10 @@ CMultiSelect.propTypes = {
   searchNoResultsLabel: PropTypes.oneOfType([PropTypes.string, PropTypes.node]),
   selectAll: PropTypes.bool,
   selectAllLabel: PropTypes.oneOfType([PropTypes.string, PropTypes.node]),
+  selectAllMode: PropTypes.oneOf(['all', 'filtered']),
+  selectAllStyle: PropTypes.oneOf(['checkbox', 'text']),
+  selectFilteredLabel: PropTypes.oneOfType([PropTypes.string, PropTypes.node]),
+  selectionLimit: PropTypes.number,
   selectionType: PropTypes.oneOf(['counter', 'tags', 'text']),
   selectionTypeCounterText: PropTypes.string,
   size: PropTypes.oneOf(['sm', 'lg']),