@primer/components 0.0.0-202198182351 → 0.0.0-20219819465

package/lib/hooks/useOpenAndCloseFocus.d.ts

@@ -3,5 +3,6 @@ export declare type UseOpenAndCloseFocusSettings = {
     initialFocusRef?: React.RefObject<HTMLElement>;
     containerRef: React.RefObject<HTMLElement>;
     returnFocusRef: React.RefObject<HTMLElement>;
+    preventFocusOnOpen?: boolean;
 };
-export declare function useOpenAndCloseFocus({ initialFocusRef, returnFocusRef, containerRef }: UseOpenAndCloseFocusSettings): void;
+export declare function useOpenAndCloseFocus({ initialFocusRef, returnFocusRef, containerRef, preventFocusOnOpen }: UseOpenAndCloseFocusSettings): void;

package/lib/hooks/useOpenAndCloseFocus.js

@@ -12,9 +12,14 @@ var _iterateFocusableElements = require("../utils/iterateFocusableElements");
 function useOpenAndCloseFocus({
   initialFocusRef,
   returnFocusRef,
-  containerRef
+  containerRef,
+  preventFocusOnOpen
 }) {
   (0, _react.useEffect)(() => {
+    if (preventFocusOnOpen) {
+      return;
+    }
+
     const returnRef = returnFocusRef.current;
 
     if (initialFocusRef && initialFocusRef.current) {
@@ -27,5 +32,5 @@ function useOpenAndCloseFocus({
     return function () {
       returnRef === null || returnRef === void 0 ? void 0 : returnRef.focus();
     };
-  }, [initialFocusRef, returnFocusRef, containerRef]);
+  }, [initialFocusRef, returnFocusRef, containerRef, preventFocusOnOpen]);
 }

package/lib/hooks/useOverlay.d.ts

@@ -7,8 +7,9 @@ export declare type UseOverlaySettings = {
     onEscape: (e: KeyboardEvent) => void;
     onClickOutside: (e: TouchOrMouseEvent) => void;
     overlayRef?: React.RefObject<HTMLDivElement>;
+    preventFocusOnOpen?: boolean;
 };
 export declare type OverlayReturnProps = {
     ref: React.RefObject<HTMLDivElement>;
 };
-export declare const useOverlay: ({ overlayRef: _overlayRef, returnFocusRef, initialFocusRef, onEscape, ignoreClickRefs, onClickOutside }: UseOverlaySettings) => OverlayReturnProps;
+export declare const useOverlay: ({ overlayRef: _overlayRef, returnFocusRef, initialFocusRef, onEscape, ignoreClickRefs, onClickOutside, preventFocusOnOpen }: UseOverlaySettings) => OverlayReturnProps;

package/lib/hooks/useOverlay.js

@@ -19,13 +19,15 @@ const useOverlay = ({
   initialFocusRef,
   onEscape,
   ignoreClickRefs,
-  onClickOutside
+  onClickOutside,
+  preventFocusOnOpen
 }) => {
   const overlayRef = (0, _useProvidedRefOrCreate.useProvidedRefOrCreate)(_overlayRef);
   (0, _useOpenAndCloseFocus.useOpenAndCloseFocus)({
     containerRef: overlayRef,
     returnFocusRef,
-    initialFocusRef
+    initialFocusRef,
+    preventFocusOnOpen
   });
   (0, _useOnOutsideClick.useOnOutsideClick)({
     containerRef: overlayRef,

package/lib/index.d.ts

@@ -24,6 +24,7 @@ export { useConfirm } from './Dialog/ConfirmationDialog';
 export { ActionList } from './ActionList';
 export { ActionMenu } from './ActionMenu';
 export type { ActionMenuProps } from './ActionMenu';
+export { default as Autocomplete } from './Autocomplete';
 export { default as Avatar } from './Avatar';
 export type { AvatarProps } from './Avatar';
 export { default as AvatarPair } from './AvatarPair';
@@ -98,6 +99,8 @@ export { default as TabNav } from './TabNav';
 export type { TabNavProps, TabNavLinkProps } from './TabNav';
 export { default as TextInput } from './TextInput';
 export type { TextInputProps } from './TextInput';
+export { default as TextInputWithTokens } from './TextInputWithTokens';
+export type { TextInputWithTokensProps } from './TextInputWithTokens';
 export { default as Text } from './Text';
 export type { TextProps } from './Text';
 export { default as Timeline } from './Timeline';

package/lib/index.js

@@ -153,6 +153,12 @@ Object.defineProperty(exports, "ActionMenu", {
     return _ActionMenu.ActionMenu;
   }
 });
+Object.defineProperty(exports, "Autocomplete", {
+  enumerable: true,
+  get: function () {
+    return _Autocomplete.default;
+  }
+});
 Object.defineProperty(exports, "Avatar", {
   enumerable: true,
   get: function () {
@@ -429,6 +435,12 @@ Object.defineProperty(exports, "TextInput", {
     return _TextInput.default;
   }
 });
+Object.defineProperty(exports, "TextInputWithTokens", {
+  enumerable: true,
+  get: function () {
+    return _TextInputWithTokens.default;
+  }
+});
 Object.defineProperty(exports, "Text", {
   enumerable: true,
   get: function () {
@@ -526,6 +538,8 @@ var _ActionList = require("./ActionList");
 
 var _ActionMenu = require("./ActionMenu");
 
+var _Autocomplete = _interopRequireDefault(require("./Autocomplete"));
+
 var _Avatar = _interopRequireDefault(require("./Avatar"));
 
 var _AvatarPair = _interopRequireDefault(require("./AvatarPair"));
@@ -600,6 +614,8 @@ var _TabNav = _interopRequireDefault(require("./TabNav"));
 
 var _TextInput = _interopRequireDefault(require("./TextInput"));
 
+var _TextInputWithTokens = _interopRequireDefault(require("./TextInputWithTokens"));
+
 var _Text = _interopRequireDefault(require("./Text"));
 
 var _Timeline = _interopRequireDefault(require("./Timeline"));

package/lib/utils/scrollIntoViewingArea.d.ts

@@ -0,0 +1 @@
+export declare const scrollIntoViewingArea: (child: HTMLElement, container: HTMLElement, direction?: 'horizontal' | 'vertical', startMargin?: number, endMargin?: number, behavior?: ScrollBehavior) => void;

package/lib/utils/scrollIntoViewingArea.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scrollIntoViewingArea = void 0;
+
+const scrollIntoViewingArea = (child, container, direction = 'vertical', startMargin = 8, endMargin = 0, behavior = 'smooth') => {
+  const startSide = direction === 'vertical' ? 'top' : 'left';
+  const endSide = direction === 'vertical' ? 'bottom' : 'right';
+  const scrollSide = direction === 'vertical' ? 'scrollTop' : 'scrollLeft';
+  const {
+    [startSide]: childStart,
+    [endSide]: childEnd
+  } = child.getBoundingClientRect();
+  const {
+    [startSide]: containerStart,
+    [endSide]: containerEnd
+  } = container.getBoundingClientRect();
+  const isChildStartAboveViewingArea = childStart < containerStart + endMargin;
+  const isChildBottomBelowViewingArea = childEnd > containerEnd - startMargin;
+
+  if (isChildStartAboveViewingArea) {
+    const scrollHeightToChildStart = childStart - containerStart + container[scrollSide];
+    container.scrollTo({
+      behavior,
+      [startSide]: scrollHeightToChildStart - endMargin
+    });
+  } else if (isChildBottomBelowViewingArea) {
+    const scrollHeightToChildBottom = childEnd - containerEnd + container[scrollSide];
+    container.scrollTo({
+      behavior,
+      [startSide]: scrollHeightToChildBottom + startMargin
+    });
+  } // either completely in view or outside viewing area on both ends, don't scroll
+
+};
+
+exports.scrollIntoViewingArea = scrollIntoViewingArea;

package/lib/utils/types/MandateProps.d.ts

@@ -0,0 +1,3 @@
+export declare type MandateProps<T extends unknown, K extends keyof T> = Omit<T, K> & {
+    [MK in K]-?: NonNullable<T[MK]>;
+};

package/lib/utils/types/MandateProps.js

@@ -0,0 +1 @@
+"use strict";

package/lib/utils/types/index.d.ts

@@ -2,3 +2,4 @@ export * from './AriaRole';
 export * from './ComponentProps';
 export * from './Flatten';
 export * from './Merge';
+export * from './MandateProps';

package/lib/utils/types/index.js

@@ -54,4 +54,17 @@ Object.keys(_Merge).forEach(function (key) {
       return _Merge[key];
     }
   });
+});
+
+var _MandateProps = require("./MandateProps");
+
+Object.keys(_MandateProps).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _MandateProps[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _MandateProps[key];
+    }
+  });
 });

package/lib-esm/AnchoredOverlay/AnchoredOverlay.d.ts

@@ -2,6 +2,7 @@ import React from 'react';
 import { OverlayProps } from '../Overlay';
 import { FocusTrapHookSettings } from '../hooks/useFocusTrap';
 import { FocusZoneHookSettings } from '../hooks/useFocusZone';
+import { PositionSettings } from '../behaviors/anchoredPosition';
 interface AnchoredOverlayPropsWithAnchor {
     /**
      * A custom function component used to render the anchor element.
@@ -52,7 +53,7 @@ interface AnchoredOverlayBaseProps extends Pick<OverlayProps, 'height' | 'width'
      */
     focusZoneSettings?: Partial<FocusZoneHookSettings>;
 }
-export declare type AnchoredOverlayProps = AnchoredOverlayBaseProps & (AnchoredOverlayPropsWithAnchor | AnchoredOverlayPropsWithoutAnchor);
+export declare type AnchoredOverlayProps = AnchoredOverlayBaseProps & (AnchoredOverlayPropsWithAnchor | AnchoredOverlayPropsWithoutAnchor) & Partial<Pick<PositionSettings, 'align' | 'side'>>;
 /**
  * An `AnchoredOverlay` provides an anchor that will open a floating overlay positioned relative to the anchor.
  * The overlay can be opened and navigated using keyboard or mouse.

package/lib-esm/AnchoredOverlay/AnchoredOverlay.js

@@ -22,7 +22,9 @@ export const AnchoredOverlay = ({
   width,
   overlayProps,
   focusTrapSettings,
-  focusZoneSettings
+  focusZoneSettings,
+  side,
+  align
 }) => {
   const anchorRef = useProvidedRefOrCreate(externalAnchorRef);
   const [overlayRef, updateOverlayRef] = useRenderForcingRef();
@@ -52,7 +54,9 @@ export const AnchoredOverlay = ({
     position
   } = useAnchoredPosition({
     anchorElementRef: anchorRef,
-    floatingElementRef: overlayRef
+    floatingElementRef: overlayRef,
+    side,
+    align
   }, [overlayRef.current]);
   useEffect(() => {
     // ensure overlay ref gets cleared when closed, so position can reset between closing/re-opening
@@ -93,4 +97,8 @@ export const AnchoredOverlay = ({
     anchorSide: position === null || position === void 0 ? void 0 : position.anchorSide
   }, overlayProps), children) : null);
 };
-AnchoredOverlay.displayName = 'AnchoredOverlay';
+AnchoredOverlay.displayName = 'AnchoredOverlay';
+AnchoredOverlay.defaultProps = {
+  side: 'outside-bottom',
+  align: 'start'
+};

package/lib-esm/Autocomplete/Autocomplete.d.ts

@@ -0,0 +1,40 @@
+import React from 'react';
+import { ComponentProps } from '../utils/types';
+import AutocompleteMenu from './AutocompleteMenu';
+declare const Autocomplete: React.FC<{
+    id?: string;
+}>;
+export declare type AutocompleteProps = ComponentProps<typeof Autocomplete>;
+export type { AutocompleteInputProps } from './AutocompleteInput';
+export type { AutocompleteMenuProps } from './AutocompleteMenu';
+export type { AutocompleteOverlayProps } from './AutocompleteOverlay';
+declare const _default: React.FC<{
+    id?: string | undefined;
+}> & {
+    AutocompleteContext: React.Context<{
+        activeDescendantRef?: React.MutableRefObject<HTMLElement | null> | undefined;
+        autocompleteSuggestion?: string | undefined;
+        id?: string | undefined;
+        inputRef?: React.MutableRefObject<HTMLInputElement | null> | undefined;
+        inputValue?: string | undefined;
+        isMenuDirectlyActivated?: boolean | undefined;
+        scrollContainerRef?: React.MutableRefObject<HTMLElement | null> | undefined;
+        selectedItemLength?: number | undefined;
+        setAutocompleteSuggestion?: React.Dispatch<React.SetStateAction<string>> | undefined;
+        setInputValue?: React.Dispatch<React.SetStateAction<string>> | undefined;
+        setIsMenuDirectlyActivated?: React.Dispatch<React.SetStateAction<boolean>> | undefined;
+        setSelectedItemLength?: React.Dispatch<React.SetStateAction<number | undefined>> | undefined;
+        setShowMenu?: React.Dispatch<React.SetStateAction<boolean>> | undefined;
+        showMenu?: boolean | undefined;
+    }>;
+    Input: import("@radix-ui/react-polymorphic").ForwardRefComponent<"input", {
+        as?: React.ComponentType<any> | undefined;
+    }>;
+    Menu: typeof AutocompleteMenu;
+    Overlay: React.FC<{
+        menuAnchorRef?: React.RefObject<HTMLElement> | undefined;
+        overlayProps?: Partial<import("..").OverlayProps> | undefined;
+        children?: React.ReactNode;
+    } & Pick<React.AriaAttributes, "aria-labelledby">>;
+};
+export default _default;

package/lib-esm/Autocomplete/Autocomplete.js

@@ -0,0 +1,47 @@
+import React, { useRef, useState } from 'react';
+import { uniqueId } from '../utils/uniqueId';
+import { AutocompleteContext } from './AutocompleteContext';
+import AutocompleteInput from './AutocompleteInput';
+import AutocompleteMenu from './AutocompleteMenu';
+import AutocompleteOverlay from './AutocompleteOverlay';
+
+const Autocomplete = ({
+  children,
+  id: idProp
+}) => {
+  const activeDescendantRef = useRef(null);
+  const scrollContainerRef = useRef(null);
+  const inputRef = useRef(null);
+  const [inputValue, setInputValue] = useState('');
+  const [showMenu, setShowMenu] = useState(false);
+  const [autocompleteSuggestion, setAutocompleteSuggestion] = useState('');
+  const [isMenuDirectlyActivated, setIsMenuDirectlyActivated] = useState(false);
+  const [selectedItemLength, setSelectedItemLength] = useState();
+  const id = idProp || uniqueId();
+  return /*#__PURE__*/React.createElement(AutocompleteContext.Provider, {
+    value: {
+      activeDescendantRef,
+      autocompleteSuggestion,
+      id,
+      inputRef,
+      inputValue,
+      isMenuDirectlyActivated,
+      scrollContainerRef,
+      selectedItemLength,
+      setAutocompleteSuggestion,
+      setInputValue,
+      setIsMenuDirectlyActivated,
+      setShowMenu,
+      setSelectedItemLength,
+      showMenu
+    }
+  }, children);
+};
+
+Autocomplete.displayName = "Autocomplete";
+export default Object.assign(Autocomplete, {
+  AutocompleteContext,
+  Input: AutocompleteInput,
+  Menu: AutocompleteMenu,
+  Overlay: AutocompleteOverlay
+});

package/lib-esm/Autocomplete/AutocompleteContext.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="react" />
+export declare const AutocompleteContext: import("react").Context<{
+    activeDescendantRef?: import("react").MutableRefObject<HTMLElement | null> | undefined;
+    autocompleteSuggestion?: string | undefined;
+    id?: string | undefined;
+    inputRef?: import("react").MutableRefObject<HTMLInputElement | null> | undefined;
+    inputValue?: string | undefined;
+    isMenuDirectlyActivated?: boolean | undefined;
+    scrollContainerRef?: import("react").MutableRefObject<HTMLElement | null> | undefined;
+    selectedItemLength?: number | undefined;
+    setAutocompleteSuggestion?: import("react").Dispatch<import("react").SetStateAction<string>> | undefined;
+    setInputValue?: import("react").Dispatch<import("react").SetStateAction<string>> | undefined;
+    setIsMenuDirectlyActivated?: import("react").Dispatch<import("react").SetStateAction<boolean>> | undefined;
+    setSelectedItemLength?: import("react").Dispatch<import("react").SetStateAction<number | undefined>> | undefined;
+    setShowMenu?: import("react").Dispatch<import("react").SetStateAction<boolean>> | undefined;
+    showMenu?: boolean | undefined;
+}>;

package/lib-esm/Autocomplete/AutocompleteContext.js

@@ -0,0 +1,2 @@
+import { createContext } from 'react';
+export const AutocompleteContext = /*#__PURE__*/createContext({});

package/lib-esm/Autocomplete/AutocompleteInput.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { ForwardRefComponent as PolymorphicForwardRefComponent } from '@radix-ui/react-polymorphic';
+import { ComponentProps } from '../utils/types';
+declare type InternalAutocompleteInputProps = {
+    as?: React.ComponentType<any>;
+};
+declare const AutocompleteInput: PolymorphicForwardRefComponent<"input", InternalAutocompleteInputProps>;
+export declare type AutocompleteInputProps = ComponentProps<typeof AutocompleteInput>;
+export default AutocompleteInput;

package/lib-esm/Autocomplete/AutocompleteInput.js

@@ -0,0 +1,131 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+import React, { useCallback, useContext, useEffect, useState } from 'react';
+import { AutocompleteContext } from './AutocompleteContext';
+import TextInput from '../TextInput';
+import { useCombinedRefs } from '../hooks/useCombinedRefs';
+const AutocompleteInput = /*#__PURE__*/React.forwardRef(({
+  as: Component = TextInput,
+  onFocus,
+  onBlur,
+  onChange,
+  onKeyDown,
+  onKeyUp,
+  onKeyPress,
+  value,
+  ...props
+}, forwardedRef) => {
+  const {
+    activeDescendantRef,
+    autocompleteSuggestion = '',
+    id,
+    inputRef,
+    inputValue = '',
+    isMenuDirectlyActivated,
+    setInputValue,
+    setShowMenu,
+    showMenu
+  } = useContext(AutocompleteContext);
+  const combinedInputRef = useCombinedRefs(inputRef, forwardedRef);
+  const [highlightRemainingText, setHighlightRemainingText] = useState(true);
+  const handleInputFocus = useCallback(event => {
+    onFocus && onFocus(event);
+    setShowMenu && setShowMenu(true);
+  }, [onFocus, setShowMenu]);
+  const handleInputBlur = useCallback(event => {
+    onBlur && onBlur(event); // HACK: wait a tick and check the focused element before hiding the autocomplete menu
+    // this prevents the menu from hiding when the user is clicking an option in the Autoselect.Menu,
+    // but still hides the menu when the user blurs the input by tabbing out or clicking somewhere else on the page
+
+    setTimeout(() => {
+      if (document.activeElement !== combinedInputRef.current) {
+        setShowMenu && setShowMenu(false);
+      }
+    }, 0);
+  }, [onBlur, setShowMenu, combinedInputRef]);
+  const handleInputChange = useCallback(event => {
+    onChange && onChange(event);
+    setInputValue && setInputValue(event.currentTarget.value);
+
+    if (!showMenu) {
+      setShowMenu && setShowMenu(true);
+    }
+  }, [onChange, setInputValue, setShowMenu, showMenu]);
+  const handleInputKeyDown = useCallback(event => {
+    var _inputRef$current;
+
+    onKeyDown && onKeyDown(event);
+
+    if (event.key === 'Backspace') {
+      setHighlightRemainingText(false);
+    }
+
+    if (event.key === 'Escape' && inputRef !== null && inputRef !== void 0 && (_inputRef$current = inputRef.current) !== null && _inputRef$current !== void 0 && _inputRef$current.value) {
+      setInputValue && setInputValue('');
+      inputRef.current.value = '';
+    }
+  }, [inputRef, setInputValue, setHighlightRemainingText, onKeyDown]);
+  const handleInputKeyUp = useCallback(event => {
+    onKeyUp && onKeyUp(event);
+
+    if (event.key === 'Backspace') {
+      setHighlightRemainingText(true);
+    }
+  }, [setHighlightRemainingText, onKeyUp]);
+  const onInputKeyPress = useCallback(event => {
+    onKeyPress && onKeyPress(event);
+
+    if (showMenu && activeDescendantRef && event.key === 'Enter' && activeDescendantRef.current) {
+      event.preventDefault();
+      event.nativeEvent.stopImmediatePropagation(); // Forward Enter key press to active descendant so that item gets activated
+
+      const activeDescendantEvent = new KeyboardEvent(event.type, event.nativeEvent);
+      activeDescendantRef.current.dispatchEvent(activeDescendantEvent);
+    }
+  }, [activeDescendantRef, showMenu, onKeyPress]);
+  useEffect(() => {
+    if (!(inputRef !== null && inputRef !== void 0 && inputRef.current)) {
+      return;
+    } // resets input value to being empty after a selection has been made
+
+
+    if (!autocompleteSuggestion) {
+      inputRef.current.value = inputValue;
+    } // TODO: fix bug where this function prevents `onChange` from being triggered if the highlighted item text
+    //       is the same as what I'm typing
+    //       e.g.: typing 'tw' highights 'two', but when I 'two', the text input change does not get triggered
+
+
+    if (highlightRemainingText && autocompleteSuggestion && (inputValue || isMenuDirectlyActivated)) {
+      inputRef.current.value = autocompleteSuggestion;
+
+      if (autocompleteSuggestion.toLowerCase().indexOf(inputValue.toLowerCase()) === 0) {
+        inputRef.current.setSelectionRange(inputValue.length, autocompleteSuggestion.length);
+      }
+    } // calling this useEffeect when `highlightRemainingText` changes breaks backspace functionality
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+
+  }, [autocompleteSuggestion, inputValue, inputRef, isMenuDirectlyActivated]);
+  useEffect(() => {
+    if (value) {
+      setInputValue && setInputValue(value.toString());
+    }
+  }, [value, setInputValue]);
+  return /*#__PURE__*/React.createElement(Component, _extends({
+    onFocus: handleInputFocus,
+    onBlur: handleInputBlur,
+    onChange: handleInputChange,
+    onKeyDown: handleInputKeyDown,
+    onKeyPress: onInputKeyPress,
+    onKeyUp: handleInputKeyUp,
+    ref: combinedInputRef,
+    "aria-controls": `${id}-listbox`,
+    "aria-autocomplete": "both",
+    role: "combobox",
+    "aria-expanded": showMenu,
+    "aria-haspopup": "listbox",
+    "aria-owns": `${id}-listbox`,
+    autocomplete: "off"
+  }, props));
+});
+export default AutocompleteInput;

package/lib-esm/Autocomplete/AutocompleteMenu.d.ts

@@ -0,0 +1,71 @@
+import React from 'react';
+import { ItemProps } from '../ActionList';
+import { ComponentProps, MandateProps } from '../utils/types';
+declare type OnSelectedChange<T> = (item: T | T[]) => void;
+declare type AutocompleteItemProps<T = Record<string, any>> = MandateProps<ItemProps, 'id'> & {
+    metadata?: T;
+};
+export declare type AutocompleteMenuInternalProps<T extends AutocompleteItemProps> = {
+    /**
+     * A menu item that is used to allow users make a selection that is not available in the array passed to the `items` prop.
+     * This menu item gets appended to the end of the list of options.
+     */
+    addNewItem?: Omit<T, 'onAction' | 'leadingVisual' | 'id'> & {
+        handleAddItem: (item: Omit<T, 'onAction' | 'leadingVisual'>) => void;
+    };
+    /**
+     * The text that appears in the menu when there are no options in the array passed to the `items` prop.
+     */
+    emptyStateText?: React.ReactNode | false;
+    /**
+     * A custom function used to filter the options in the array passed to the `items` prop.
+     * By default, we filter out items that don't match the value of the autocomplete text input. The default filter is not case-sensitive.
+     */
+    filterFn?: (item: T, i: number) => boolean;
+    /**
+     * The options for field values that are displayed in the dropdown menu.
+     * One or more may be selected depending on the value of the `selectionVariant` prop.
+     */
+    items: T[];
+    /**
+     * Whether the data is loaded for the menu items
+     */
+    loading?: boolean;
+    /**
+     * The IDs of the selected items
+     */
+    selectedItemIds: Array<string | number>;
+    /**
+     * The sort function that is applied to the options in the array passed to the `items` prop after the user closes the menu.
+     * By default, selected items are sorted to the top after the user closes the menu.
+     */
+    sortOnCloseFn?: (itemIdA: string | number, itemIdB: string | number) => number;
+    /**
+     * Whether there can be one item selected from the menu or multiple items selected from the menu
+     */
+    selectionVariant?: 'single' | 'multiple';
+    /**
+     * Function that gets called when the menu is opened or closed
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * The function that is called when an item in the list is selected or deselected
+     */
+    onSelectedChange?: OnSelectedChange<T>;
+    /**
+     * If the menu is rendered in a scrolling element other than the `Autocomplete.Overlay` component,
+     * pass the ref of that element to `customScrollContainerRef` to ensure the container automatically
+     * scrolls when the user highlights an item in the menu that is outside the scroll container
+     */
+    customScrollContainerRef?: React.MutableRefObject<HTMLElement | null>;
+} & Pick<React.AriaAttributes, 'aria-labelledby'>;
+declare function AutocompleteMenu<T extends AutocompleteItemProps>(props: AutocompleteMenuInternalProps<T>): JSX.Element;
+declare namespace AutocompleteMenu {
+    var defaultProps: {
+        emptyStateText: string;
+        selectionVariant: string;
+    };
+    var displayName: string;
+}
+export declare type AutocompleteMenuProps = ComponentProps<typeof AutocompleteMenu>;
+export default AutocompleteMenu;