@itwin/itwinui-react 3.11.3 → 3.12.1

package/esm/core/ComboBox/ComboBox.js

@@ -1,315 +1,436 @@
-/*---------------------------------------------------------------------------------------------
- * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
- * See LICENSE.md in the project root for license terms and full copyright notice.
- *--------------------------------------------------------------------------------------------*/
 import * as React from 'react';
 import { MenuExtraContent } from '../Menu/MenuExtraContent.js';
 import { SelectTag } from '../Select/SelectTag.js';
 import { Text } from '../Typography/Text.js';
-import { mergeRefs, useLatestRef, useLayoutEffect, AutoclearingHiddenLiveRegion, useId, } from '../../utils/index.js';
+import {
+  mergeRefs,
+  useLatestRef,
+  useLayoutEffect,
+  AutoclearingHiddenLiveRegion,
+  useId,
+  useControlledState,
+} from '../../utils/index.js';
 import { usePopover } from '../Popover/Popover.js';
-import { ComboBoxActionContext, comboBoxReducer, ComboBoxRefsContext, ComboBoxStateContext, } from './helpers.js';
+import { ComboBoxRefsContext, ComboBoxStateContext } from './helpers.js';
 import { ComboBoxEndIcon } from './ComboBoxEndIcon.js';
 import { ComboBoxInput } from './ComboBoxInput.js';
 import { ComboBoxInputContainer } from './ComboBoxInputContainer.js';
 import { ComboBoxMenu } from './ComboBoxMenu.js';
 import { ComboBoxMenuItem } from './ComboBoxMenuItem.js';
-// Type guard for enabling multiple
 const isMultipleEnabled = (variable, multiple) => {
-    return multiple && (Array.isArray(variable) || variable === undefined);
+  return (
+    multiple &&
+    (Array.isArray(variable) || variable === null || variable === undefined)
+  );
 };
-// Type guard for user onChange
 const isSingleOnChange = (onChange, multiple) => {
-    return !multiple;
+  return !multiple;
 };
-/** Returns either `option.id` or derives a stable id using `idPrefix` and `option.label` (without whitespace) */
 const getOptionId = (option, idPrefix) => {
-    return option.id ?? `${idPrefix}-option-${option.label.replace(/\s/g, '-')}`;
+  return option.id ?? `${idPrefix}-option-${option.label.replace(/\s/g, '-')}`;
 };
-/**
- * ComboBox component that allows typing a value to filter the options in dropdown list.
- * Values can be selected either using mouse clicks or using the Enter key.
- * @example
- * <ComboBox
- *   options={[
- *     { label: 'Item 1', value: 1 },
- *     { label: 'Item 2', value: 2 },
- *     { label: 'Item 3', value: 3 },
- *   ]}
- *   onChange={() => {}}
- * />
- */
 export const ComboBox = React.forwardRef((props, forwardedRef) => {
-    const idPrefix = useId();
-    const { options, value: valueProp, onChange, filterFunction, inputProps, endIconProps, dropdownMenuProps, emptyStateMessage = 'No options found', itemRenderer, enableVirtualization = false, multiple = false, onShow: onShowProp, onHide: onHideProp, id = inputProps?.id ? `iui-${inputProps.id}-cb` : idPrefix, ...rest } = props;
-    // Refs get set in subcomponents
-    const inputRef = React.useRef(null);
-    const menuRef = React.useRef(null);
-    const onChangeProp = useLatestRef(onChange);
-    const optionsRef = useLatestRef(options);
-    // Record to store all extra information (e.g. original indexes), where the key is the id of the option
-    const optionsExtraInfoRef = React.useRef({});
-    // Clear the extra info when the options change so that it can be reinitialized below
-    React.useEffect(() => {
-        optionsExtraInfoRef.current = {};
-    }, [options]);
-    // Initialize the extra info only if it is not already initialized
-    if (options.length > 0 &&
-        Object.keys(optionsExtraInfoRef.current).length === 0) {
-        options.forEach((option, index) => {
-            optionsExtraInfoRef.current[getOptionId(option, id)] = {
-                __originalIndex: index,
-            };
-        });
-    }
-    // Get indices of selected elements in options array when we have selected values.
-    const getSelectedIndexes = React.useCallback(() => {
-        if (isMultipleEnabled(valueProp, multiple)) {
-            const indexArray = [];
-            valueProp?.forEach((value) => {
-                const indexToAdd = options.findIndex((option) => option.value === value);
-                if (indexToAdd > -1) {
-                    indexArray.push(indexToAdd);
-                }
-            });
-            return indexArray;
-        }
-        else {
-            return options.findIndex((option) => option.value === valueProp);
-        }
-    }, [multiple, options, valueProp]);
-    // Reducer where all the component-wide state is stored
-    const [{ isOpen, selected, focusedIndex }, dispatch] = React.useReducer(comboBoxReducer, {
-        isOpen: false,
-        selected: getSelectedIndexes(),
-        focusedIndex: -1,
+  const idPrefix = useId();
+  const defaultFilterFunction = React.useCallback((options, inputValue) => {
+    return options.filter((option) =>
+      option.label.toLowerCase().includes(inputValue.toLowerCase()),
+    );
+  }, []);
+  const {
+    options,
+    value: valueProp,
+    onChange,
+    filterFunction = defaultFilterFunction,
+    inputProps,
+    endIconProps,
+    dropdownMenuProps,
+    emptyStateMessage = 'No options found',
+    itemRenderer,
+    enableVirtualization = false,
+    multiple = false,
+    onShow: onShowProp,
+    onHide: onHideProp,
+    id = inputProps?.id ? `iui-${inputProps.id}-cb` : idPrefix,
+    defaultValue,
+    ...rest
+  } = props;
+  const inputRef = React.useRef(null);
+  const menuRef = React.useRef(null);
+  const onChangeProp = useLatestRef(onChange);
+  const optionsRef = useLatestRef(options);
+  const filterFunctionRef = useLatestRef(filterFunction);
+  const optionsExtraInfo = React.useMemo(() => {
+    const newOptionsExtraInfo = {};
+    options.forEach((option, index) => {
+      newOptionsExtraInfo[getOptionId(option, id)] = {
+        __originalIndex: index,
+      };
     });
-    const onShowRef = useLatestRef(onShowProp);
-    const onHideRef = useLatestRef(onHideProp);
-    const show = React.useCallback(() => {
-        dispatch({ type: 'open' });
-        onShowRef.current?.();
-    }, [onShowRef]);
-    const hide = React.useCallback(() => {
-        dispatch({ type: 'close' });
-        onHideRef.current?.();
-    }, [onHideRef]);
-    useLayoutEffect(() => {
-        // When the dropdown opens
-        if (isOpen) {
-            inputRef.current?.focus(); // Focus the input
-            // Reset the filtered list (does not reset when multiple enabled)
-            if (!multiple) {
-                setFilteredOptions(optionsRef.current);
-                dispatch({ type: 'focus', value: undefined });
-            }
-        }
-        // When the dropdown closes
-        else {
-            // Reset the focused index
-            dispatch({ type: 'focus', value: undefined });
-            // Reset the input value if not multiple
-            if (!isMultipleEnabled(selected, multiple)) {
-                setInputValue(selected != undefined && selected >= 0
-                    ? optionsRef.current[selected]?.label
-                    : '');
-            }
-        }
-    }, [isOpen, multiple, optionsRef, selected]);
-    // Update filtered options to the latest value options according to input value
-    const [filteredOptions, setFilteredOptions] = React.useState(options);
-    React.useEffect(() => {
-        if (inputValue) {
-            setFilteredOptions(filterFunction?.(options, inputValue) ??
-                options.filter((option) => option.label.toLowerCase().includes(inputValue.toLowerCase())));
-        }
-        else {
-            setFilteredOptions(options);
-        }
-        dispatch({ type: 'focus', value: undefined });
-        // Only need to call on options update
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [options]);
-    // Filter options based on input value
-    const [inputValue, setInputValue] = React.useState(inputProps?.value?.toString() ?? '');
-    const [liveRegionSelection, setLiveRegionSelection] = React.useState('');
-    const handleOnInput = React.useCallback((event) => {
-        const { value } = event.currentTarget;
-        setInputValue(value);
-        show(); // reopen when typing
-        setFilteredOptions(filterFunction?.(optionsRef.current, value) ??
-            optionsRef.current.filter((option) => option.label.toLowerCase().includes(value.toLowerCase())));
-        if (focusedIndex != -1) {
-            dispatch({ type: 'focus', value: -1 });
-        }
-        inputProps?.onChange?.(event);
-    }, [filterFunction, focusedIndex, inputProps, optionsRef, show]);
-    // When the value prop changes, update the selected index/indices
-    React.useEffect(() => {
-        if (isMultipleEnabled(valueProp, multiple)) {
-            if (valueProp) {
-                // If user provided array of selected values
-                const indexes = valueProp.map((value) => {
-                    return options.findIndex((option) => option.value === value);
-                });
-                dispatch({
-                    type: 'multiselect',
-                    value: indexes.filter((index) => index !== -1), // Add available options
-                });
-            }
-            else {
-                // if user provided one value or undefined
-                dispatch({
-                    type: 'multiselect',
-                    value: [], // Add empty list
-                });
-            }
-        }
-        else {
-            dispatch({
-                type: 'select',
-                value: options.findIndex((option) => option.value === valueProp),
-            });
-        }
-    }, [valueProp, options, multiple]);
-    const isMenuItemSelected = React.useCallback((index) => {
-        if (isMultipleEnabled(selected, multiple)) {
-            return !!selected.includes(index);
-        }
-        else {
-            return selected === index;
-        }
-    }, [multiple, selected]);
-    // Generates new array when item is added or removed
-    const selectedChangeHandler = React.useCallback((__originalIndex, action) => {
-        if (action === 'added') {
-            return [...selected, __originalIndex];
-        }
-        else {
-            return selected.filter((index) => index !== __originalIndex);
-        }
-    }, [selected]);
-    // Calls user defined onChange
-    const onChangeHandler = React.useCallback((__originalIndex, actionType, newArray) => {
-        if (isSingleOnChange(onChangeProp.current, multiple)) {
-            onChangeProp.current?.(optionsRef.current[__originalIndex]?.value);
-        }
-        else {
-            actionType &&
-                newArray &&
-                onChangeProp.current?.(newArray?.map((item) => optionsRef.current[item]?.value), {
-                    value: optionsRef.current[__originalIndex]?.value,
-                    type: actionType,
-                });
-        }
-    }, [multiple, onChangeProp, optionsRef]);
-    const onClickHandler = React.useCallback((__originalIndex) => {
-        inputRef.current?.focus({ preventScroll: true }); // return focus to input
-        if (optionsRef.current[__originalIndex]?.disabled) {
-            return;
-        }
-        if (isMultipleEnabled(selected, multiple)) {
-            const actionType = isMenuItemSelected(__originalIndex)
-                ? 'removed'
-                : 'added';
-            const newArray = selectedChangeHandler(__originalIndex, actionType);
-            dispatch({ type: 'multiselect', value: newArray });
-            onChangeHandler(__originalIndex, actionType, newArray);
-            // update live region
-            setLiveRegionSelection(newArray
-                .map((item) => optionsRef.current[item]?.label)
-                .filter(Boolean)
-                .join(', '));
+    return newOptionsExtraInfo;
+  }, [id, options]);
+  const getSelectedIndexes = React.useCallback(
+    (value) => {
+      if (value === undefined) {
+        return undefined;
+      }
+      if (isMultipleEnabled(value, multiple)) {
+        const indexArray = [];
+        value?.forEach((value) => {
+          const indexToAdd = options.findIndex(
+            (option) => option.value === value,
+          );
+          if (indexToAdd > -1) {
+            indexArray.push(indexToAdd);
+          }
+        });
+        return indexArray;
+      } else {
+        return options.findIndex((option) => option.value === value);
+      }
+    },
+    [multiple, options],
+  );
+  const [selectedIndexes, setSelectedIndexes] = useControlledState(
+    getSelectedIndexes(defaultValue) ?? (multiple ? [] : -1),
+    getSelectedIndexes(valueProp),
+  );
+  const previousValue = React.useRef(valueProp);
+  useLayoutEffect(() => {
+    if (valueProp !== previousValue.current) {
+      previousValue.current = valueProp;
+      if (valueProp === undefined) {
+        if (isMultipleEnabled(selectedIndexes, multiple)) {
+          setSelectedIndexes([]);
+        } else {
+          setSelectedIndexes(-1);
         }
-        else {
-            dispatch({ type: 'select', value: __originalIndex });
-            hide();
-            onChangeHandler(__originalIndex);
+      }
+    }
+  }, [multiple, selectedIndexes, setSelectedIndexes, valueProp]);
+  const [isOpen, setIsOpen] = React.useState(false);
+  const [focusedIndex, setFocusedIndex] = React.useState(-1);
+  const onShowRef = useLatestRef(onShowProp);
+  const onHideRef = useLatestRef(onHideProp);
+  const show = React.useCallback(() => {
+    setIsOpen(true);
+    onShowRef.current?.();
+  }, [onShowRef]);
+  const hide = React.useCallback(() => {
+    setIsOpen(false);
+    onHideRef.current?.();
+  }, [onHideRef]);
+  useLayoutEffect(() => {
+    if (isOpen) {
+      inputRef.current?.focus();
+      if (!isMultipleEnabled(selectedIndexes, multiple)) {
+        setFocusedIndex(selectedIndexes ?? -1);
+      }
+    } else {
+      setFocusedIndex(-1);
+      if (!isMultipleEnabled(selectedIndexes, multiple)) {
+        setInputValue(
+          selectedIndexes >= 0
+            ? optionsRef.current[selectedIndexes]?.label ?? ''
+            : '',
+        );
+      }
+    }
+  }, [isOpen, multiple, optionsRef, selectedIndexes]);
+  const previousOptions = React.useRef(options);
+  React.useEffect(() => {
+    if (options !== previousOptions.current) {
+      previousOptions.current = options;
+      onOptionsChange();
+    }
+    function onOptionsChange() {
+      if (!isMultipleEnabled(selectedIndexes, multiple)) {
+        setFocusedIndex(selectedIndexes);
+      } else {
+        setFocusedIndex(-1);
+      }
+      if (!isMultipleEnabled(selectedIndexes, multiple) && !isOpen) {
+        setInputValue(
+          selectedIndexes >= 0 ? options[selectedIndexes]?.label : '',
+        );
+      }
+    }
+  }, [options, isOpen, multiple, selectedIndexes]);
+  const [inputValue, setInputValue] = React.useState(
+    inputProps?.value?.toString() ?? '',
+  );
+  const [isInputDirty, setIsInputDirty] = React.useState(false);
+  const filteredOptions = React.useMemo(() => {
+    if (!isInputDirty) {
+      return options;
+    }
+    return filterFunctionRef.current?.(options, inputValue);
+  }, [filterFunctionRef, inputValue, options, isInputDirty]);
+  const [liveRegionSelection, setLiveRegionSelection] = React.useState('');
+  const handleOnInput = React.useCallback(
+    (event) => {
+      const { value } = event.currentTarget;
+      setInputValue(value);
+      show();
+      setIsInputDirty(true);
+      if (focusedIndex != -1) {
+        setFocusedIndex(-1);
+      }
+      inputProps?.onChange?.(event);
+    },
+    [focusedIndex, inputProps, show],
+  );
+  const isMenuItemSelected = React.useCallback(
+    (index) => {
+      if (isMultipleEnabled(selectedIndexes, multiple)) {
+        return selectedIndexes.includes(index);
+      } else {
+        return selectedIndexes === index;
+      }
+    },
+    [multiple, selectedIndexes],
+  );
+  const selectedChangeHandler = React.useCallback(
+    (__originalIndex, action) => {
+      if (!isMultipleEnabled(selectedIndexes, multiple)) {
+        return;
+      }
+      if (action === 'added') {
+        return [...selectedIndexes, __originalIndex];
+      } else {
+        return selectedIndexes?.filter((index) => index !== __originalIndex);
+      }
+    },
+    [selectedIndexes, multiple],
+  );
+  const onChangeHandler = React.useCallback(
+    (__originalIndex, actionType, newSelectedIndexes) => {
+      if (isSingleOnChange(onChangeProp.current, multiple)) {
+        onChangeProp.current?.(optionsRef.current[__originalIndex]?.value);
+      } else {
+        actionType &&
+          newSelectedIndexes &&
+          onChangeProp.current?.(
+            newSelectedIndexes?.map(
+              (index) => optionsRef.current[index]?.value,
+            ),
+            {
+              value: optionsRef.current[__originalIndex]?.value,
+              type: actionType,
+            },
+          );
+      }
+    },
+    [multiple, onChangeProp, optionsRef],
+  );
+  const onClickHandler = React.useCallback(
+    (__originalIndex) => {
+      inputRef.current?.focus({
+        preventScroll: true,
+      });
+      if (optionsRef.current[__originalIndex]?.disabled) {
+        return;
+      }
+      setIsInputDirty(false);
+      if (multiple) {
+        const actionType = isMenuItemSelected(__originalIndex)
+          ? 'removed'
+          : 'added';
+        const newSelectedIndexes = selectedChangeHandler(
+          __originalIndex,
+          actionType,
+        );
+        if (newSelectedIndexes == null) {
+          return;
         }
-    }, [
-        selectedChangeHandler,
-        isMenuItemSelected,
-        multiple,
-        onChangeHandler,
-        selected,
-        optionsRef,
-        hide,
-    ]);
-    const getMenuItem = React.useCallback((option, filteredIndex) => {
-        const optionId = getOptionId(option, id);
-        const { __originalIndex } = optionsExtraInfoRef.current[optionId];
-        const { icon, startIcon: startIconProp, label, ...restOptions } = option;
-        const startIcon = startIconProp ?? icon;
-        const customItem = itemRenderer
-            ? itemRenderer(option, {
-                isFocused: focusedIndex === __originalIndex,
-                isSelected: selected === __originalIndex,
-                index: __originalIndex,
-                id: optionId,
-            })
-            : null;
-        return customItem ? (React.cloneElement(customItem, {
+        setSelectedIndexes(newSelectedIndexes);
+        onChangeHandler(__originalIndex, actionType, newSelectedIndexes);
+        setLiveRegionSelection(
+          newSelectedIndexes
+            .map((item) => optionsRef.current[item]?.label)
+            .filter(Boolean)
+            .join(', '),
+        );
+      } else {
+        setSelectedIndexes(__originalIndex);
+        hide();
+        onChangeHandler(__originalIndex);
+      }
+    },
+    [
+      selectedChangeHandler,
+      isMenuItemSelected,
+      multiple,
+      onChangeHandler,
+      optionsRef,
+      hide,
+      setSelectedIndexes,
+    ],
+  );
+  const getMenuItem = React.useCallback(
+    (option, filteredIndex) => {
+      const optionId = getOptionId(option, id);
+      const { __originalIndex } = optionsExtraInfo[optionId];
+      const { icon, startIcon: startIconProp, label, ...restOptions } = option;
+      const startIcon = startIconProp ?? icon;
+      const customItem = itemRenderer
+        ? itemRenderer(option, {
+            isFocused: focusedIndex === __originalIndex,
+            isSelected: isMenuItemSelected(__originalIndex),
+            index: __originalIndex,
+            id: optionId,
+          })
+        : null;
+      return customItem
+        ? React.cloneElement(customItem, {
             onClick: (e) => {
-                onClickHandler(__originalIndex);
-                customItem.props.onClick?.(e);
+              onClickHandler(__originalIndex);
+              customItem.props.onClick?.(e);
             },
-            // ComboBox.MenuItem handles scrollIntoView, data-iui-index and focused through context
-            // but we still need to pass them here for backwards compatibility with MenuItem
             focused: focusedIndex === __originalIndex,
             'data-iui-index': __originalIndex,
             'data-iui-filtered-index': filteredIndex,
             ref: mergeRefs(customItem.props.ref, (el) => {
-                if (!enableVirtualization && focusedIndex === __originalIndex) {
-                    el?.scrollIntoView({ block: 'nearest' });
-                }
+              if (!enableVirtualization && focusedIndex === __originalIndex) {
+                el?.scrollIntoView({
+                  block: 'nearest',
+                });
+              }
             }),
-        })) : (React.createElement(ComboBoxMenuItem, { key: optionId, id: optionId, startIcon: startIcon, ...restOptions, isSelected: isMenuItemSelected(__originalIndex), onClick: () => {
+          })
+        : React.createElement(
+            ComboBoxMenuItem,
+            {
+              key: optionId,
+              id: optionId,
+              startIcon: startIcon,
+              ...restOptions,
+              isSelected: isMenuItemSelected(__originalIndex),
+              onClick: () => {
                 onClickHandler(__originalIndex);
-            }, index: __originalIndex, "data-iui-filtered-index": filteredIndex }, label));
-    }, [
-        enableVirtualization,
-        focusedIndex,
-        id,
-        isMenuItemSelected,
-        itemRenderer,
-        onClickHandler,
-        selected,
-    ]);
-    const emptyContent = React.useMemo(() => (React.createElement(React.Fragment, null, React.isValidElement(emptyStateMessage) ? (emptyStateMessage) : (React.createElement(MenuExtraContent, null,
-        React.createElement(Text, { isMuted: true }, emptyStateMessage))))), [emptyStateMessage]);
-    const popover = usePopover({
-        visible: isOpen,
-        onVisibleChange: (open) => (open ? show() : hide()),
-        matchWidth: true,
-        closeOnOutsideClick: true,
-        interactions: { click: false, focus: true },
-    });
-    return (React.createElement(ComboBoxRefsContext.Provider, { value: { inputRef, menuRef, optionsExtraInfoRef } },
-        React.createElement(ComboBoxActionContext.Provider, { value: dispatch },
-            React.createElement(ComboBoxStateContext.Provider, { value: {
-                    id,
-                    isOpen,
-                    focusedIndex,
-                    onClickHandler,
-                    enableVirtualization,
-                    filteredOptions,
-                    getMenuItem,
-                    multiple,
-                    popover,
-                    show,
-                    hide,
-                } },
-                React.createElement(ComboBoxInputContainer, { ref: forwardedRef, disabled: inputProps?.disabled, ...rest },
-                    React.createElement(React.Fragment, null,
-                        React.createElement(ComboBoxInput, { value: inputValue, disabled: inputProps?.disabled, ...inputProps, onChange: handleOnInput, selectTags: isMultipleEnabled(selected, multiple)
-                                ? selected.map((index) => {
-                                    const item = optionsRef.current[index];
-                                    return (React.createElement(SelectTag, { key: item.label, label: item.label }));
-                                })
-                                : undefined })),
-                    React.createElement(ComboBoxEndIcon, { ...endIconProps, disabled: inputProps?.disabled, isOpen: isOpen }),
-                    multiple ? (React.createElement(AutoclearingHiddenLiveRegion, { text: liveRegionSelection })) : null),
-                React.createElement(ComboBoxMenu, { as: 'div', ...dropdownMenuProps }, filteredOptions.length > 0 && !enableVirtualization
-                    ? filteredOptions.map(getMenuItem)
-                    : emptyContent)))));
+              },
+              index: __originalIndex,
+              'data-iui-filtered-index': filteredIndex,
+            },
+            label,
+          );
+    },
+    [
+      enableVirtualization,
+      focusedIndex,
+      id,
+      isMenuItemSelected,
+      itemRenderer,
+      onClickHandler,
+      optionsExtraInfo,
+    ],
+  );
+  const emptyContent = React.useMemo(
+    () =>
+      React.createElement(
+        React.Fragment,
+        null,
+        React.isValidElement(emptyStateMessage)
+          ? emptyStateMessage
+          : React.createElement(
+              MenuExtraContent,
+              null,
+              React.createElement(
+                Text,
+                {
+                  isMuted: true,
+                },
+                emptyStateMessage,
+              ),
+            ),
+      ),
+    [emptyStateMessage],
+  );
+  const popover = usePopover({
+    visible: isOpen,
+    onVisibleChange: (open) => (open ? show() : hide()),
+    matchWidth: true,
+    closeOnOutsideClick: true,
+    interactions: {
+      click: false,
+      focus: true,
+    },
+  });
+  return React.createElement(
+    ComboBoxRefsContext.Provider,
+    {
+      value: {
+        inputRef,
+        menuRef,
+        optionsExtraInfo,
+      },
+    },
+    React.createElement(
+      ComboBoxStateContext.Provider,
+      {
+        value: {
+          id,
+          isOpen,
+          focusedIndex,
+          setFocusedIndex,
+          onClickHandler,
+          enableVirtualization,
+          filteredOptions,
+          getMenuItem,
+          multiple,
+          popover,
+          show,
+          hide,
+        },
+      },
+      React.createElement(
+        ComboBoxInputContainer,
+        {
+          ref: forwardedRef,
+          disabled: inputProps?.disabled,
+          ...rest,
+        },
+        React.createElement(
+          React.Fragment,
+          null,
+          React.createElement(ComboBoxInput, {
+            value: inputValue,
+            disabled: inputProps?.disabled,
+            ...inputProps,
+            onChange: handleOnInput,
+            selectTags: isMultipleEnabled(selectedIndexes, multiple)
+              ? selectedIndexes
+                  ?.map((index) => {
+                    const item = options[index];
+                    return React.createElement(SelectTag, {
+                      key: item.label,
+                      label: item.label,
+                    });
+                  })
+                  .filter(Boolean)
+              : undefined,
+          }),
+        ),
+        React.createElement(ComboBoxEndIcon, {
+          ...endIconProps,
+          disabled: inputProps?.disabled,
+          isOpen: isOpen,
+        }),
+        multiple
+          ? React.createElement(AutoclearingHiddenLiveRegion, {
+              text: liveRegionSelection,
+            })
+          : null,
+      ),
+      React.createElement(
+        ComboBoxMenu,
+        {
+          as: 'div',
+          ...dropdownMenuProps,
+        },
+        filteredOptions.length > 0 && !enableVirtualization
+          ? filteredOptions.map(getMenuItem)
+          : emptyContent,
+      ),
+    ),
+  );
 });