@oracle/oraclejet-preact 14.0.0

package/es/PRIVATE_SelectCommon.js

@@ -0,0 +1,691 @@
+/* @oracle/oraclejet-preact: 14.0.0 */
+import { jsxs, jsx } from 'preact/jsx-runtime';
+import { useCallback, useMemo, useEffect, useRef, useState } from 'preact/hooks';
+import "./PRIVATE_SelectCommon.css";
+import { HighlightText } from './UNSAFE_HighlightText.js';
+import { List, SkeletonContainer } from './PRIVATE_List.js';
+import { Flex } from './UNSAFE_Flex.js';
+import { Skeleton } from './UNSAFE_Skeleton.js';
+import { Logger } from './utils/UNSAFE_logger.js';
+import { Floating } from './UNSAFE_Floating.js';
+import { Layer } from './UNSAFE_Layer.js';
+import { coerceArray } from './utils/UNSAFE_arrayUtils.js';
+import { usePress } from './hooks/UNSAFE_usePress.js';
+import './UNSAFE_ThemedIcons.js';
+import { classNames } from './utils/UNSAFE_classNames.js';
+import { IcoCaretDown as SvgIcoCaretDown } from './UNSAFE_Icons.js';
+import { FormFieldContext } from './hooks/UNSAFE_useFormFieldContext.js';
+import { InlineUserAssistance } from './UNSAFE_UserAssistance.js';
+import { useTranslationBundle } from './hooks/UNSAFE_useTranslationBundle.js';
+import { getClientHints } from './utils/PRIVATE_clientHints.js';
+import 'preact';
+import './utils/UNSAFE_mergeProps.js';
+import './utils/UNSAFE_keys.js';
+import './LoadMoreCollection-5d3b319f.js';
+import './PRIVATE_Collection.js';
+import './hooks/UNSAFE_useViewportIntersect.js';
+import './PRIVATE_VirtualizedCollection.js';
+import './hooks/UNSAFE_useTabbableMode.js';
+import './UNSAFE_FocusTrap.js';
+import 'preact/compat';
+import './utils/PRIVATE_tabbableUtils.js';
+import './_curry1-d822c6e1.js';
+import './_curry2-50442f66.js';
+import './_curry3-ddab9fe1.js';
+import './hooks/UNSAFE_useId.js';
+import './hooks/PRIVATE_useSelection.js';
+import './hooks/PRIVATE_useCurrentKey.js';
+import './hooks/PRIVATE_useCollectionFocusRing.js';
+import './hooks/PRIVATE_useTabbableModeSet.js';
+import './hooks/PRIVATE_useItemAction.js';
+import './utils/PRIVATE_collectionUtils.js';
+import './UNSAFE_Selector.js';
+import './UNSAFE_Icon.js';
+import './tslib.es6-8b94ba02.js';
+import './hooks/UNSAFE_useTooltip.js';
+import './hooks/UNSAFE_useHover.js';
+import './hooks/UNSAFE_useToggle.js';
+import './hooks/UNSAFE_useFocus.js';
+import './hooks/UNSAFE_useTouch.js';
+import './hooks/UNSAFE_useAnimation.js';
+import './index-14bba6f7.js';
+import './hooks/UNSAFE_useUser.js';
+import './UNSAFE_Environment.js';
+import './utils/PRIVATE_floatingUtils.js';
+import './utils/PRIVATE_refUtils.js';
+import './hooks/UNSAFE_useOutsideClick.js';
+import './hooks/UNSAFE_useTheme.js';
+import './utils/UNSAFE_interpolations/dimensions.js';
+import './utils/UNSAFE_size.js';
+import './utils/UNSAFE_mergeInterpolations.js';
+import './_has-c4aaaf43.js';
+import './utils/UNSAFE_interpolations/boxalignment.js';
+import './keys-fed67954.js';
+import './utils/UNSAFE_interpolations/flexbox.js';
+import './utils/UNSAFE_interpolations/flexitem.js';
+import './utils/UNSAFE_interpolations/borders.js';
+import './UNSAFE_ComponentMessage.js';
+import './PRIVATE_Message.js';
+import './utils/PRIVATE_timer.js';
+import './UNSAFE_Button.js';
+import './UNSAFE_BaseButton.js';
+import './hooks/UNSAFE_useActive.js';
+import './utils/UNSAFE_getLocale.js';
+import './utils/UNSAFE_stringUtils.js';
+import './utils/UNSAFE_soundUtils.js';
+import './PRIVATE_TransitionGroup.js';
+import './hooks/UNSAFE_useMessagesContext.js';
+import './UNSAFE_HiddenAccessible.js';
+import './hooks/UNSAFE_useFormContext.js';
+
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+function renderItemText(item, itemText) {
+    var _a;
+    // if item-text is a string and the data has the specified field, return it;
+    // otherwise log an error
+    if (typeof itemText === 'string') {
+        if ((_a = item.data) === null || _a === void 0 ? void 0 : _a.hasOwnProperty(itemText)) {
+            const retData = item.data[itemText];
+            return String(retData);
+        }
+        Logger.error('SelectMultiple: itemText specifies field that does not exist: ' + itemText);
+        // return undefined if the field doesn't exist
+        return undefined;
+    }
+    // if item-text is a function, call it to create a display label
+    return itemText(item);
+}
+
+const itemStyles = "_1yyyqzd";
+
+const noOp = () => {};
+
+function DefaultList({
+  accessibleSummary,
+  currentItemVariant,
+  currentKey,
+  data,
+  itemText,
+  onCurrentKeyChange,
+  onItemAction,
+  onLoadRange = noOp,
+  onSelectionChange,
+  searchText,
+  selectedKeys,
+  selectionMode
+}) {
+  const listItemRenderer = useCallback(listItemContext => {
+    const itemContext = {
+      data: listItemContext.data,
+      key: listItemContext.metadata.key,
+      metadata: listItemContext.metadata
+    };
+    const renderedItemText = renderItemText(itemContext, itemText);
+    return jsxs(Flex, {
+      children: [listItemContext.selector && listItemContext.selector(), jsx("div", Object.assign({
+        class: itemStyles
+      }, {
+        children: jsx(HighlightText, Object.assign({
+          matchText: searchText
+        }, {
+          children: renderedItemText
+        }))
+      }))]
+    });
+  }, [itemText, searchText]);
+  const keys = useMemo(() => {
+    return {
+      all: false,
+      keys: selectedKeys !== null && selectedKeys !== void 0 ? selectedKeys : new Set()
+    };
+  }, [selectedKeys]);
+  return jsx(List, Object.assign({
+    accessibleSummary: accessibleSummary,
+    allowTabbableMode: false,
+    currentItemVariant: currentItemVariant,
+    currentKey: currentKey,
+    data: data !== null && data !== void 0 ? data : null,
+    loadingIndicator: loadingIndicator,
+    onCurrentKeyChange: onCurrentKeyChange,
+    onItemAction: onItemAction,
+    onLoadRange: onLoadRange,
+    onSelectionChange: onSelectionChange,
+    role: "listbox",
+    selectedKeys: keys,
+    selectionMode: selectionMode
+  }, {
+    children: context => listItemRenderer(context)
+  }));
+}
+/**
+ * Custom 3 Skeleton loader for select multiple
+ * TODO: to remove this once https://jira.oraclecorp.com/jira/browse/JET-51527 is solved
+ */
+
+const loadingIndicator = jsx(SkeletonContainer, Object.assign({
+  minimumCount: 3
+}, {
+  children: () => {
+    return jsx(Flex, Object.assign({
+      height: "12x",
+      align: "center"
+    }, {
+      children: jsx(Skeleton, {
+        height: "4x"
+      })
+    }));
+  }
+}));
+
+const KEYS = {
+    TAB: 'Tab',
+    ENTER: 'Enter',
+    ESC: 'Escape',
+    SPACE: 'Space',
+    LEFT: 'ArrowLeft',
+    UP: 'ArrowUp',
+    RIGHT: 'ArrowRight',
+    DOWN: 'ArrowDown',
+    SHIFT_LEFT: 'ShiftLeft',
+    SHIFT_RIGHT: 'ShiftRight',
+    CTRL_LEFT: 'ControlLeft',
+    CTRL_RIGHT: 'ControlRight',
+    ALT_LEFT: 'AltLeft',
+    ALT_RIGHT: 'AltRight',
+    PAGE_UP: 'PageUp',
+    PAGE_DOWN: 'PageDown',
+    HOME: 'Home',
+    END: 'End',
+    BACKSPACE: 'Backspace',
+    DELETE: 'Delete'
+};
+const isControlKey = (event) => {
+    switch (event.code) {
+        case KEYS.SHIFT_LEFT:
+        case KEYS.SHIFT_RIGHT:
+        case KEYS.CTRL_LEFT:
+        case KEYS.CTRL_RIGHT:
+        case KEYS.ALT_LEFT:
+        case KEYS.ALT_RIGHT:
+            return true;
+        default:
+            return event.metaKey || event.ctrlKey;
+    }
+};
+const isFunctionKey = (event) => {
+    return /\bF([1-9]|1[0-2])\b/i.test(event.code);
+};
+const isControlOrFunctionKey = (event) => {
+    return isControlKey(event) || isFunctionKey(event);
+};
+const isSimpleClick = (event) => {
+    return event.button === 0 && !event.ctrlKey;
+};
+const preventDefaultForCurrentTarget = (event) => {
+    if (event.currentTarget === event.target) {
+        event.preventDefault();
+    }
+};
+
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+const isPointOutside = (event, ref) => {
+    const target = event.target;
+    if (target) {
+        const doc = getDocument(target);
+        if (!doc.contains(target))
+            return false;
+    }
+    return ref.every((elRef) => { var _a; return !((_a = elRef.current) === null || _a === void 0 ? void 0 : _a.contains(target)); });
+};
+const getDocument = (node) => { var _a; return (_a = node === null || node === void 0 ? void 0 : node.ownerDocument) !== null && _a !== void 0 ? _a : document; };
+const useOutsideMousedown = ({ isDisabled: disabled = false, ref, handler }) => {
+    useEffect(() => {
+        const refs = coerceArray(ref);
+        if (!handler ||
+            disabled ||
+            (refs.length > 0 && refs.findIndex((elRef) => elRef.current === null) > -1))
+            return;
+        const onMouseDown = (event) => {
+            if (isPointOutside(event, refs)) {
+                handler === null || handler === void 0 ? void 0 : handler(event);
+            }
+        };
+        const firstElRef = refs[0];
+        const doc = getDocument(firstElRef.current);
+        if (doc) {
+            doc.addEventListener('mousedown', onMouseDown, true);
+            return () => {
+                doc.removeEventListener('mousedown', onMouseDown, true);
+            };
+        }
+        return undefined;
+    }, [disabled, handler, ref]);
+};
+
+const rootStyles$4 = {
+  base: "rodq5u"
+};
+function Dropdown({
+  anchorRef,
+  children,
+  dropdownRef,
+  id,
+  isOpen,
+  onAutoDismiss
+}) {
+  var _a;
+
+  const handleAutoDismiss = useCallback(event => {
+    onAutoDismiss === null || onAutoDismiss === void 0 ? void 0 : onAutoDismiss(event);
+  }, [onAutoDismiss]);
+  const handleKeyDown = useCallback(event => {
+    if (event.defaultPrevented || isControlOrFunctionKey(event)) {
+      return;
+    }
+
+    switch (event.code) {
+      case KEYS.ESC:
+      case KEYS.TAB:
+        handleAutoDismiss(event);
+        break;
+    }
+  }, [handleAutoDismiss]); // use the mousedown event to be consistent with legacy JET and so that we're hiding the dropdown
+  // on the same event where focus will transfer
+
+  useOutsideMousedown({
+    isDisabled: !isOpen,
+    ref: [anchorRef, dropdownRef],
+    handler: handleAutoDismiss
+  }); // TODO: get dropdown y (mainAxis) offset from --oj-c-PRIVATE-DO-NOT-USE-private-core-global-dropdown-offset
+
+  const offsetValue = {
+    mainAxis: 4,
+    crossAxis: 0
+  };
+  const inlineStyle = {
+    minWidth: `${(_a = anchorRef.current) === null || _a === void 0 ? void 0 : _a.offsetWidth}px`
+  };
+  return !isOpen ? null : jsx(Layer, Object.assign({
+    logicalParentRef: anchorRef
+  }, {
+    children: jsx(Floating, Object.assign({
+      anchorRef: anchorRef,
+      ref: dropdownRef,
+      placement: "bottom-start",
+      offsetValue: offsetValue
+    }, {
+      children: jsx("div", Object.assign({
+        class: rootStyles$4.base,
+        id: id,
+        style: inlineStyle,
+        onKeyDown: handleKeyDown,
+        onMouseDown: preventDefaultForCurrentTarget
+      }, {
+        children: children
+      }))
+    }))
+  }));
+}
+
+const ojButtonHeight = '2.75rem'; // TODO: replace this with var(--oj-button-sm-height) once it is available
+
+const ojButtonSmHeight = '2.25rem'; // TODO: replace this with var(--oj-button-border-radius) once it is available
+
+const ojButtonBorderRadius = 'var(--oj-c-PRIVATE-DO-NOT-USE-core-border-radius-md)'; // TODO: replace this with var(--oj-button-borderless-chrome-text-color) once it is available
+
+const ojButtonBorderlessChromeTextColor = 'var(--oj-c-PRIVATE-DO-NOT-USE-core-text-color-primary)'; // TODO: replace this with var (--oj-button-borderless-chrome-text-color-disabled) once it is available
+
+const ojButtonBorderlessChromeTextColorDisabled = 'var(--oj-c-PRIVATE-DO-NOT-USE-core-text-color-disabled)'; // TODO: replace this with var(--oj-button-borderless-chrome-text-color-hover) once it is available
+
+const ojButtonBorderlessChromeTextColorHover = 'var(--oj-c-PRIVATE-DO-NOT-USE-core-text-color-primary)'; // TODO: replace this with var(--oj-button-borderless-chrome-bg-color-hover) once it is available
+
+const ojButtonBorderlessChromeBgColorHover = 'var(--oj-c-PRIVATE-DO-NOT-USE-core-bg-color-hover)'; // TODO: replace this with var(--oj-button-borderless-chrome-border-color-hover) once it is available
+
+const ojButtonBorderlessChromeBorderColorHover = 'transparent'; // TODO: replace this with var(--oj-c-PRIVATE-DO-NOT-USE-button-icon-size) once it is available
+
+const ojButtonIconSize = 'var(--oj-c-PRIVATE-DO-NOT-USE-core-icon-size-lg)';
+const rootStyles$3 = {
+  base: "_1p4a3mx",
+  sizeMd: "_1rgdb4j",
+  sizeSm: "_1ofqe55",
+  enabled: "_1wv2eih",
+  disabled: "_1ky568z"
+};
+
+const noop = () => {};
+
+function DropdownArrow({
+  isDisabled = false,
+  onClick,
+  size = 'md'
+}) {
+  const preventDefault = useCallback(event => {
+    event.preventDefault();
+  }, []);
+  const {
+    pressProps
+  } = usePress(onClick !== null && onClick !== void 0 ? onClick : noop, {
+    isDisabled
+  });
+  const styleClasses = classNames([rootStyles$3.base, size === 'sm' ? rootStyles$3.sizeSm : rootStyles$3.sizeMd, isDisabled ? rootStyles$3.disabled : rootStyles$3.enabled]);
+  return jsx("span", Object.assign({
+    "aria-hidden": "true",
+    class: styleClasses,
+    tabIndex: -1,
+    onMouseDown: preventDefault
+  }, pressProps, {
+    children: jsx(SvgIcoCaretDown, {})
+  }));
+}
+
+const rootStyles$2 = {
+  base: "_1q6vvtt",
+  // TODO: These should really be applied directly to the child ListView so that the content
+  // displays under the padding when scrolled, but we can't apply styles to the child collection.
+  // TODO: Also need to figure out how to determine whether the collection is a ListView (in
+  // the collectionRenderer case) in order to apply this styling.
+  topGap: "_150xyb6",
+  bottomGap: "_11gmmhj",
+  loading: "_1616wls"
+};
+function DropdownList({
+  children,
+  hasBottomGap = true,
+  isLoading = false
+}) {
+  const styleClasses = classNames([rootStyles$2.base, rootStyles$2.topGap, hasBottomGap && rootStyles$2.bottomGap, isLoading && rootStyles$2.loading]);
+  return jsx("div", Object.assign({
+    class: styleClasses,
+    onMouseDown: preventDefaultForCurrentTarget
+  }, {
+    children: children
+  }));
+}
+
+const rootStyles$1 = "tx33v5";
+function DropdownUserAssistance(props) {
+  // Prevent the focus from transferring when the user clicks on an empty/non-clickable area
+  // of the user assistance
+  const handleMouseDown = useCallback(event => {
+    var _a; // Don't call preventDefault when the user clicks on the help source link, so that the
+    // focus is allowed to transfer in that case.
+
+
+    if (((_a = event.target) === null || _a === void 0 ? void 0 : _a.tagName) !== 'A') {
+      event.preventDefault();
+    }
+  }, []);
+  return jsx(FormFieldContext.Provider, Object.assign({
+    value: {
+      isFocused: true
+    }
+  }, {
+    children: jsx("div", Object.assign({
+      class: rootStyles$1,
+      onMouseDown: handleMouseDown
+    }, {
+      children: jsx(InlineUserAssistance, Object.assign({}, props))
+    }))
+  }));
+}
+
+const rootStyles = "_1bg2e2a";
+function EmptyResults() {
+  const translations = useTranslationBundle('@oracle/oraclejet-preact'); // TODO: figure out whether we need a separate resource string for this message;
+  // (JET-53984 - Preact Select* components: empty results message)
+  // call preventDefault for mousedown on this div so that focus does not transfer from
+  // the input
+
+  return jsx("div", Object.assign({
+    class: rootStyles,
+    onMouseDown: preventDefaultForCurrentTarget
+  }, {
+    children: translations.select_noMatchesFound()
+  }));
+}
+
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+/**
+ * Helper function to determine whether the current device is a mobile device
+ * @returns true if running on a mobile device, false otherwise
+ */
+function isMobile() {
+    const deviceType = getClientHints().deviceType;
+    return deviceType === 'phone' || deviceType === 'tablet';
+}
+function isBeforeDataFetch(data) {
+    return data.sizePrecision === 'atLeast' && data.totalSize === 0;
+}
+
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+/**
+ * Hook that manages state and behavior for a Select* component.  This hook creates state
+ * variables and event listeners, returning properties to apply to components internally
+ * rendered by a Select* component, as well as state information.
+ *
+ * @param data Specifies data for the dropdown list.
+ * @param inputRef Ref to the input element.
+ * @param isFocused Specifies whether the component has focus.
+ * @param onFilter Callback function to trigger loading data for the dropdown list,
+ * which may or may not be filtered by user entered text.
+ *
+ * @returns Component state and event listeners.
+ */
+function useSelectCommon({ data, inputRef, isFocused, onFilter }) {
+    const mainFieldRef = useRef(null);
+    const dropdownRef = useRef(null);
+    const [isDropdownOpen, setDropdownOpen] = useState(false);
+    const [currentRow, setCurrentRow] = useState({
+        rowKey: undefined
+    });
+    const [selectedKeys, setSelectedKeys] = useState();
+    const [isUserFiltering, setUserFiltering] = useState(false);
+    const [userInput, setUserInput] = useState();
+    const [searchText, setSearchText] = useState();
+    const onMouseDown = useCallback((event) => {
+        // const target = event.target as HTMLElement;
+        if (event.defaultPrevented || !isSimpleClick(event)) {
+            return;
+        }
+        if (!isDropdownOpen) {
+            setDropdownOpen(true);
+        }
+        // this is needed to focus the input when clicking on the inside label when there is no
+        // value;  otherwise the component looks focused but doesn't actually have physical focus
+        setTimeout(function () {
+            var _a;
+            (_a = inputRef.current) === null || _a === void 0 ? void 0 : _a.focus();
+        }, 0);
+    }, [isDropdownOpen]);
+    const handleDropdownArrowClick = useCallback(() => {
+        var _a;
+        setDropdownOpen(!isDropdownOpen);
+        // focus the input so that if the user Tabs afterwards, it loses focus and the dropdown closes
+        (_a = inputRef.current) === null || _a === void 0 ? void 0 : _a.focus();
+    }, [isDropdownOpen]);
+    const handleDropdownAutoDismiss = useCallback((event) => {
+        var _a, _b, _c;
+        if (isDropdownOpen) {
+            setDropdownOpen(false);
+            switch (event === null || event === void 0 ? void 0 : event.type) {
+                case 'keydown':
+                    const keyboardEvent = event;
+                    switch (keyboardEvent.code) {
+                        case KEYS.ESC:
+                            // focus the input when the user cancels out of the dropdown
+                            (_a = inputRef.current) === null || _a === void 0 ? void 0 : _a.focus();
+                            break;
+                        default:
+                            break;
+                    }
+                    break;
+                case 'mousedown':
+                    // if focus is in the dropdown, focus the input before the dropdown is hidden so that
+                    // focus will transfer correctly when the target is not focusable;
+                    // otherwise the text cursor appears in the input again
+                    if ((_b = dropdownRef.current) === null || _b === void 0 ? void 0 : _b.contains(document.activeElement)) {
+                        (_c = inputRef.current) === null || _c === void 0 ? void 0 : _c.focus();
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+    }, [isDropdownOpen]);
+    const handleUpDownArrowKeys = useCallback((event) => {
+        var _a, _b, _c, _d;
+        if (!isDropdownOpen) {
+            setDropdownOpen(true);
+        }
+        else {
+            // transfer physical focus into the dropdown
+            const firstFocusableElem = (_a = dropdownRef.current) === null || _a === void 0 ? void 0 : _a.querySelector('[tabindex="0"]');
+            firstFocusableElem === null || firstFocusableElem === void 0 ? void 0 : firstFocusableElem.focus();
+            // if there is no current item set, make the first item current
+            if (data !== undefined && currentRow.rowKey === undefined) {
+                setCurrentRow({ rowKey: (_d = (_c = (_b = data === null || data === void 0 ? void 0 : data.data) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.metadata) === null || _d === void 0 ? void 0 : _d.key });
+            }
+        }
+        // prevent the page from scrolling
+        event.preventDefault();
+    }, [currentRow, data, isDropdownOpen]);
+    const handleMainFieldKeyDown = useCallback((event) => {
+        // const target = event.target as HTMLElement;
+        // ignore control key and function key
+        if (isControlOrFunctionKey(event)) {
+            return;
+        }
+        switch (event.code) {
+            case KEYS.PAGE_UP:
+            case KEYS.PAGE_DOWN:
+                // prevent the page from scrolling
+                event.preventDefault();
+                return;
+            case KEYS.UP:
+            case KEYS.DOWN:
+                // prevent the page from scrolling
+                event.preventDefault();
+                break;
+            case KEYS.ESC:
+                if (isDropdownOpen) {
+                    setDropdownOpen(false);
+                    event.preventDefault();
+                    // JET-53183 - core pack compat: stop propagation of handled events
+                    // we don't want a parent collection component to stop editing the row when we close
+                    // the dropdown
+                    event.stopPropagation();
+                }
+                break;
+            default:
+                break;
+        }
+    }, [isDropdownOpen]);
+    const handleMainFieldKeyUp = useCallback((event) => {
+        // ignore control key and function key
+        if (isControlOrFunctionKey(event)) {
+            return;
+        }
+        switch (event.code) {
+            case KEYS.UP:
+            case KEYS.DOWN:
+                handleUpDownArrowKeys(event);
+                break;
+            default:
+                break;
+        }
+    }, [handleUpDownArrowKeys]);
+    const handleInput = useCallback((detail) => {
+        var _a;
+        if (!isDropdownOpen) {
+            setDropdownOpen(true);
+        }
+        setUserFiltering(true);
+        setUserInput(detail.value);
+        const str = (_a = detail.value) === null || _a === void 0 ? void 0 : _a.trim();
+        setSearchText(str);
+        onFilter === null || onFilter === void 0 ? void 0 : onFilter({ searchText: str });
+    }, [isDropdownOpen, onFilter]);
+    const onCurrentKeyChange = useCallback((detail) => {
+        setCurrentRow({ rowKey: detail.value });
+    }, []);
+    const stopFiltering = useCallback(() => {
+        setUserFiltering(false);
+        setUserInput('');
+        setSearchText('');
+    }, []);
+    // the user is not actively filtering if the dropdown is closed and the component doesn't
+    // have focus
+    useEffect(() => {
+        if (!isDropdownOpen && !isFocused && isUserFiltering) {
+            stopFiltering();
+        }
+    }, [isDropdownOpen, isFocused, isUserFiltering]);
+    // need to call onFilter with undefined searchText when the dropdown opens and the
+    // user is NOT filtering
+    useEffect(() => {
+        if (isDropdownOpen && !isUserFiltering) {
+            onFilter === null || onFilter === void 0 ? void 0 : onFilter({ searchText: undefined });
+        }
+    }, [isDropdownOpen, isUserFiltering, onFilter]);
+    return {
+        currentRow,
+        dropdownRef,
+        handleDropdownArrowClick,
+        handleDropdownAutoDismiss,
+        handleInput,
+        handleMainFieldKeyDown,
+        handleMainFieldKeyUp,
+        handleUpDownArrowKeys,
+        isDropdownOpen,
+        // the field should remain to look focused while the dropdown is open,
+        // in case physical focus is in the dropdown
+        isFocused: isFocused || isDropdownOpen,
+        isUserFiltering,
+        mainFieldRef,
+        onCurrentKeyChange,
+        onMouseDown,
+        searchText,
+        selectedKeys,
+        setCurrentRow,
+        setDropdownOpen,
+        setSelectedKeys,
+        stopFiltering,
+        userInput
+    };
+}
+
+/**
+ * @license
+ * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.
+ * The Universal Permissive License (UPL), Version 1.0
+ * as shown at https://oss.oracle.com/licenses/upl/
+ * @ignore
+ */
+
+export { DefaultList, Dropdown, DropdownArrow, DropdownList, DropdownUserAssistance, EmptyResults, KEYS, isBeforeDataFetch, isControlKey, isControlOrFunctionKey, isFunctionKey, isMobile, isSimpleClick, preventDefaultForCurrentTarget, renderItemText, useSelectCommon };
+/*  */
+//# sourceMappingURL=PRIVATE_SelectCommon.js.map