@primer/components 0.0.0-202195195330 → 0.0.0-202195195659

package/lib/Autocomplete/AutocompleteOverlay.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _hooks = require("../hooks");
+
+var _Overlay = _interopRequireDefault(require("../Overlay"));
+
+var _AutocompleteContext = require("./AutocompleteContext");
+
+var _useCombinedRefs = require("../hooks/useCombinedRefs");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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); }
+
+// TODO: consider making 'aria-labelledby' required
+const AutocompleteOverlay = ({
+  menuAnchorRef,
+  overlayProps,
+  children
+}) => {
+  const {
+    inputRef,
+    scrollContainerRef,
+    selectedItemLength,
+    setShowMenu,
+    showMenu = false
+  } = (0, _react.useContext)(_AutocompleteContext.AutocompleteContext);
+  const {
+    floatingElementRef,
+    position
+  } = (0, _hooks.useAnchoredPosition)({
+    side: 'outside-bottom',
+    align: 'start',
+    anchorElementRef: menuAnchorRef ? menuAnchorRef : inputRef
+  }, [showMenu, selectedItemLength]);
+  const combinedOverlayRef = (0, _useCombinedRefs.useCombinedRefs)(scrollContainerRef, floatingElementRef);
+  const closeOptionList = (0, _react.useCallback)(() => {
+    setShowMenu && setShowMenu(false);
+  }, [setShowMenu]);
+  return /*#__PURE__*/_react.default.createElement(_Overlay.default, _extends({
+    returnFocusRef: inputRef,
+    preventFocusOnOpen: true,
+    onClickOutside: closeOptionList,
+    onEscape: closeOptionList,
+    ref: combinedOverlayRef,
+    top: position === null || position === void 0 ? void 0 : position.top,
+    left: position === null || position === void 0 ? void 0 : position.left,
+    visibility: showMenu ? 'visible' : 'hidden',
+    sx: {
+      overflow: 'auto'
+    }
+  }, overlayProps), children);
+};
+
+AutocompleteOverlay.displayName = "AutocompleteOverlay";
+AutocompleteOverlay.displayName = 'AutocompleteOverlay';
+var _default = AutocompleteOverlay;
+exports.default = _default;

package/lib/Autocomplete/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './Autocomplete';
+export type { AutocompleteMenuProps, AutocompleteInputProps, AutocompleteOverlayProps } from './Autocomplete';

package/lib/Autocomplete/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _Autocomplete.default;
+  }
+});
+
+var _Autocomplete = _interopRequireDefault(require("./Autocomplete"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/lib/FilteredActionList/FilteredActionList.js

@@ -7,6 +7,8 @@ exports.FilteredActionList = FilteredActionList;
 
 var _react = _interopRequireWildcard(require("react"));
 
+var _ssr = require("@react-aria/ssr");
+
 var _TextInput = _interopRequireDefault(require("../TextInput"));
 
 var _Box = _interopRequireDefault(require("../Box"));
@@ -27,7 +29,7 @@ var _useProvidedRefOrCreate = require("../hooks/useProvidedRefOrCreate");
 
 var _useScrollFlash = _interopRequireDefault(require("../hooks/useScrollFlash"));
 
-var _ssr = require("@react-aria/ssr");
+var _scrollIntoViewingArea = require("../utils/scrollIntoViewingArea");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -37,34 +39,6 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 
 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); }
 
-function scrollIntoViewingArea(child, container, margin = 8, behavior = 'smooth') {
-  const {
-    top: childTop,
-    bottom: childBottom
-  } = child.getBoundingClientRect();
-  const {
-    top: containerTop,
-    bottom: containerBottom
-  } = container.getBoundingClientRect();
-  const isChildTopAboveViewingArea = childTop < containerTop + margin;
-  const isChildBottomBelowViewingArea = childBottom > containerBottom - margin;
-
-  if (isChildTopAboveViewingArea) {
-    const scrollHeightToChildTop = childTop - containerTop + container.scrollTop;
-    container.scrollTo({
-      behavior,
-      top: scrollHeightToChildTop - margin
-    });
-  } else if (isChildBottomBelowViewingArea) {
-    const scrollHeightToChildBottom = childBottom - containerBottom + container.scrollTop;
-    container.scrollTo({
-      behavior,
-      top: scrollHeightToChildBottom + margin
-    });
-  } // either completely in view or outside viewing area on both ends, don't scroll
-
-}
-
 const StyledHeader = _styledComponents.default.div.withConfig({
   displayName: "FilteredActionList__StyledHeader",
   componentId: "yg3jkv-0"
@@ -111,7 +85,7 @@ function FilteredActionList({
       activeDescendantRef.current = current;
 
       if (current && scrollContainerRef.current && directlyActivated) {
-        scrollIntoViewingArea(current, scrollContainerRef.current);
+        (0, _scrollIntoViewingArea.scrollIntoViewingArea)(current, scrollContainerRef.current);
       }
     }
   }, [// List ref isn't set while loading.  Need to re-bind focus zone when it changes
@@ -119,7 +93,7 @@ function FilteredActionList({
   (0, _react.useEffect)(() => {
     // if items changed, we want to instantly move active descendant into view
     if (activeDescendantRef.current && scrollContainerRef.current) {
-      scrollIntoViewingArea(activeDescendantRef.current, scrollContainerRef.current, undefined, 'auto');
+      (0, _scrollIntoViewingArea.scrollIntoViewingArea)(activeDescendantRef.current, scrollContainerRef.current, 'vertical', undefined, undefined, 'auto');
     }
   }, [items]);
   (0, _useScrollFlash.default)(scrollContainerRef);

package/lib/Overlay.d.ts

@@ -4,7 +4,7 @@ import { ComponentProps } from './utils/types';
 import { TouchOrMouseEvent } from './hooks';
 import { SxProp } from './sx';
 import { AnchorSide } from './behaviors/anchoredPosition';
-declare type StyledOverlayProps = {
+export declare type StyledOverlayProps = {
     width?: keyof typeof widthMap;
     height?: keyof typeof heightMap;
     maxHeight?: keyof Omit<typeof heightMap, 'auto' | 'initial'>;
@@ -40,6 +40,7 @@ export declare type OverlayProps = {
     top: number;
     left: number;
     portalContainerName?: string;
+    preventFocusOnOpen?: boolean;
 } & Omit<ComponentProps<typeof StyledOverlay>, 'visibility' | keyof SystemPositionProps>;
 /**
  * An `Overlay` is a flexible floating surface, used to display transient content such as menus,

package/lib/Overlay.js

@@ -113,6 +113,7 @@ const Overlay = /*#__PURE__*/_react.default.forwardRef(({
   left,
   anchorSide,
   portalContainerName,
+  preventFocusOnOpen,
   ...rest
 }, forwardedRef) => {
   const overlayRef = (0, _react.useRef)(null);
@@ -128,7 +129,8 @@ const Overlay = /*#__PURE__*/_react.default.forwardRef(({
     onEscape,
     ignoreClickRefs,
     onClickOutside,
-    initialFocusRef
+    initialFocusRef,
+    preventFocusOnOpen
   });
   (0, _react.useEffect)(() => {
     var _combinedRef$current;
@@ -157,9 +159,8 @@ const Overlay = /*#__PURE__*/_react.default.forwardRef(({
       easing: slideAnimationEasing
     });
   }, [anchorSide, slideAnimationDistance, slideAnimationEasing, visibility]);
-  return /*#__PURE__*/_react.default.createElement(_Portal.default, {
-    containerName: portalContainerName
-  }, /*#__PURE__*/_react.default.createElement(StyledOverlay, _extends({
+
+  const styledOverlay = /*#__PURE__*/_react.default.createElement(StyledOverlay, _extends({
     height: height,
     role: role
   }, rest, {
@@ -170,7 +171,11 @@ const Overlay = /*#__PURE__*/_react.default.forwardRef(({
       ...rest.style,
       '--styled-overlay-visibility': visibility
     }
-  })));
+  }));
+
+  return /*#__PURE__*/_react.default.createElement(_Portal.default, {
+    containerName: portalContainerName
+  }, styledOverlay);
 });
 
 Overlay.defaultProps = {

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,14 +19,19 @@ const useOverlay = ({
   initialFocusRef,
   onEscape,
   ignoreClickRefs,
-  onClickOutside
+  onClickOutside,
+  preventFocusOnOpen
 }) => {
   const overlayRef = (0, _useProvidedRefOrCreate.useProvidedRefOrCreate)(_overlayRef);
-  (0, _useOpenAndCloseFocus.useOpenAndCloseFocus)({
-    containerRef: overlayRef,
-    returnFocusRef,
-    initialFocusRef
-  });
+
+  if (!preventFocusOnOpen) {
+    (0, _useOpenAndCloseFocus.useOpenAndCloseFocus)({
+      containerRef: overlayRef,
+      returnFocusRef,
+      initialFocusRef
+    });
+  }
+
   (0, _useOnOutsideClick.useOnOutsideClick)({
     containerRef: overlayRef,
     ignoreClickRefs,

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';

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 () {
@@ -532,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"));

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.d.ts

@@ -12,3 +12,6 @@ export declare type ComponentProps<T> = T extends React.ComponentType<infer Prop
  */
 export declare type Flatten<T extends unknown> = T extends (infer U)[] ? U : never;
 export declare type AriaRole = 'alert' | 'alertdialog' | 'application' | 'article' | 'banner' | 'button' | 'cell' | 'checkbox' | 'columnheader' | 'combobox' | 'complementary' | 'contentinfo' | 'definition' | 'dialog' | 'directory' | 'document' | 'feed' | 'figure' | 'form' | 'grid' | 'gridcell' | 'group' | 'heading' | 'img' | 'link' | 'list' | 'listbox' | 'listitem' | 'log' | 'main' | 'marquee' | 'math' | 'menu' | 'menubar' | 'menuitem' | 'menuitemcheckbox ' | 'menuitemradio' | 'navigation' | 'none' | 'note' | 'option' | 'presentation' | 'progressbar' | 'radio' | 'radiogroup' | 'region' | 'row' | 'rowgroup' | 'rowheader' | 'scrollbar' | 'search' | 'searchbox' | 'separator' | 'slider' | 'spinbutton' | 'status' | 'switch' | 'tab' | 'table' | 'tablist' | 'tabpanel' | 'term' | 'textbox' | 'timer' | 'toolbar' | 'tooltip' | 'tree' | 'treegrid' | 'treeitem';
+export declare type MandateProps<T extends {}, K extends keyof T> = Omit<T, K> & {
+    [MK in K]-?: NonNullable<T[MK]>;
+};

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 type * as Polymorphic from '@radix-ui/react-polymorphic';
+import { ComponentProps } from '../utils/types';
+declare type InternalAutocompleteInputProps = {
+    as?: React.ComponentType<any>;
+};
+declare const AutocompleteInput: Polymorphic.ForwardRefComponent<"input", InternalAutocompleteInputProps>;
+export declare type AutocompleteInputProps = ComponentProps<typeof AutocompleteInput>;
+export default AutocompleteInput;

package/lib-esm/Autocomplete/AutocompleteInput.js

@@ -0,0 +1,122 @@
+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,
+  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]);
+  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;
+
+    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]);
+  const handleInputKeyUp = useCallback(event => {
+    if (event.key === 'Backspace') {
+      setHighlightRemainingText(true);
+    }
+  }, [setHighlightRemainingText]);
+  const onInputKeyPress = useCallback(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]);
+  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);
+      }
+    }
+  }, [autocompleteSuggestion, inputValue]);
+  useEffect(() => {
+    if (value) {
+      setInputValue && setInputValue(value.toString());
+    }
+  }, [value]);
+  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;