downshift 9.3.2 → 9.4.0-alpha.0

package/dist/hooks/testUtils/MemoizedItem.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+type MemoizedItemProps = {
+    index: number;
+    item: string;
+    getItemProps: (options: Record<string, unknown>) => React.HTMLAttributes<HTMLLIElement>;
+    stringItem: string;
+    [key: string]: unknown;
+};
+export declare const MemoizedItem: React.NamedExoticComponent<MemoizedItemProps>;
+export {};

package/dist/hooks/testUtils/fixtures.d.ts

@@ -0,0 +1,16 @@
+export declare const items: string[];
+export declare const dataTestIds: {
+    toggleButton: string;
+    menu: string;
+    item: (index: number) => string;
+    input: string;
+    selectedItemPrefix: string;
+    selectedItem: (index: number) => string;
+};
+export declare const defaultIds: {
+    labelId: string;
+    menuId: string;
+    getItemId: (index: number) => string;
+    toggleButtonId: string;
+    inputId: string;
+};

package/dist/hooks/testUtils/index.d.ts

@@ -0,0 +1,4 @@
+export { items, dataTestIds, defaultIds } from './fixtures';
+export { MemoizedItem } from './MemoizedItem';
+export { waitForDebouncedA11yStatusUpdate, getLabel, getMenu, getToggleButton, getItemAtIndex, getItems, clickOnItemAtIndex, clickOnToggleButton, mouseMoveItemAtIndex, mouseLeaveItemAtIndex, keyDownOnToggleButton, getA11yStatusContainer, tab, } from './interactions';
+export { initialFocusAndOpenTestCases, initialNoFocusOrOpenTestCases, } from './testCases';

package/dist/hooks/testUtils/interactions.d.ts

@@ -0,0 +1,16 @@
+import type userEvent from '@testing-library/user-event';
+export declare const waitForDebouncedA11yStatusUpdate: (shouldBeCleared?: boolean) => void;
+type UserEvent = ReturnType<typeof userEvent.setup>;
+export declare function getLabel(): HTMLElement;
+export declare function getMenu(): HTMLElement;
+export declare function getToggleButton(): HTMLElement;
+export declare function getItemAtIndex(index: number): HTMLElement | undefined;
+export declare function getItems(): HTMLElement[];
+export declare function clickOnItemAtIndex(user: UserEvent, index: number): Promise<void>;
+export declare function clickOnToggleButton(user: UserEvent): Promise<void>;
+export declare function mouseMoveItemAtIndex(user: UserEvent, index: number): Promise<void>;
+export declare function mouseLeaveItemAtIndex(user: UserEvent, index: number): Promise<void>;
+export declare function keyDownOnToggleButton(user: UserEvent, keys: string): Promise<void>;
+export declare function getA11yStatusContainer(): HTMLElement | null;
+export declare function tab(user: UserEvent, shiftKey?: boolean): Promise<void>;
+export {};

package/dist/hooks/testUtils/testCases.d.ts

@@ -0,0 +1,2 @@
+export declare const initialFocusAndOpenTestCases: (boolean | undefined)[][];
+export declare const initialNoFocusOrOpenTestCases: (boolean | undefined)[][];

package/dist/hooks/useCombobox/__tests__/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from '@testing-library/react';
+export { items, dataTestIds, defaultIds, waitForDebouncedA11yStatusUpdate, MemoizedItem, getLabel, getMenu, getToggleButton, getItemAtIndex, getItems, clickOnItemAtIndex, clickOnToggleButton, mouseMoveItemAtIndex, mouseLeaveItemAtIndex, keyDownOnToggleButton, getA11yStatusContainer, tab, initialFocusAndOpenTestCases, initialNoFocusOrOpenTestCases, } from '../../../testUtils';
+export { renderUseCombobox } from './renderUseCombobox';
+export { renderCombobox, getInput } from './renderCombobox';
+export { keyDownOnInput, changeInputValue, clickOnInput } from './interactions';

package/dist/hooks/useCombobox/__tests__/utils/interactions.d.ts

@@ -0,0 +1,6 @@
+import type userEvent from '@testing-library/user-event';
+type UserEvent = ReturnType<typeof userEvent.setup>;
+export declare function keyDownOnInput(user: UserEvent, keys: string): Promise<void>;
+export declare function changeInputValue(user: UserEvent, inputValue: string): Promise<void>;
+export declare function clickOnInput(user: UserEvent): Promise<void>;
+export {};

package/dist/hooks/useCombobox/__tests__/utils/renderCombobox.d.ts

@@ -0,0 +1,72 @@
+import * as React from 'react';
+import { UseComboboxProps } from '../../index.types';
+import useCombobox from '../..';
+type DropdownComboboxProps = Partial<UseComboboxProps<string>> & {
+    renderSpy: jest.Mock;
+    renderItem?: (props: {
+        index: number;
+        item: string;
+        getItemProps: ReturnType<typeof useCombobox>['getItemProps'];
+        stringItem: string;
+    }) => React.ReactNode;
+};
+export declare function renderCombobox(props?: Omit<DropdownComboboxProps, 'renderSpy'>, uiCallback?: (ui: React.ReactElement) => React.ReactElement): {
+    renderSpy: jest.Mock<any, any, any>;
+    rerender: (p: Omit<DropdownComboboxProps, "renderSpy">) => void;
+    user: import("@testing-library/user-event").UserEvent;
+    container: HTMLElement;
+    baseElement: HTMLElement;
+    debug: (baseElement?: ReactDOMClient.Container | any | Array<ReactDOMClient.Container | any> | undefined, maxLength?: number | undefined, options?: import("node_modules/pretty-format/build").OptionsReceived | undefined) => void;
+    unmount: () => void;
+    asFragment: () => DocumentFragment;
+    getByLabelText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement;
+    getAllByLabelText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement[];
+    queryByLabelText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement | null;
+    queryAllByLabelText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement[];
+    findByLabelText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByLabelText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByPlaceholderText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement;
+    getAllByPlaceholderText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    queryByPlaceholderText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByPlaceholderText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    findByPlaceholderText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByPlaceholderText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement;
+    getAllByText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement[];
+    queryByText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement | null;
+    queryAllByText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined) => HTMLElement[];
+    findByText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").SelectorMatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByAltText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement;
+    getAllByAltText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    queryByAltText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByAltText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    findByAltText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByAltText: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByTitle: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement;
+    getAllByTitle: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    queryByTitle: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByTitle: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    findByTitle: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByTitle: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByDisplayValue: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement;
+    getAllByDisplayValue: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    queryByDisplayValue: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByDisplayValue: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    findByDisplayValue: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByDisplayValue: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByRole: (role: import("@testing-library/react").ByRoleMatcher, options?: import("@testing-library/react").ByRoleOptions | undefined) => HTMLElement;
+    getAllByRole: (role: import("@testing-library/react").ByRoleMatcher, options?: import("@testing-library/react").ByRoleOptions | undefined) => HTMLElement[];
+    queryByRole: (role: import("@testing-library/react").ByRoleMatcher, options?: import("@testing-library/react").ByRoleOptions | undefined) => HTMLElement | null;
+    queryAllByRole: (role: import("@testing-library/react").ByRoleMatcher, options?: import("@testing-library/react").ByRoleOptions | undefined) => HTMLElement[];
+    findByRole: (role: import("@testing-library/react").ByRoleMatcher, options?: import("@testing-library/react").ByRoleOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByRole: (role: import("@testing-library/react").ByRoleMatcher, options?: import("@testing-library/react").ByRoleOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+    getByTestId: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement;
+    getAllByTestId: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    queryByTestId: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement | null;
+    queryAllByTestId: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined) => HTMLElement[];
+    findByTestId: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement>;
+    findAllByTestId: (id: import("@testing-library/react").Matcher, options?: import("@testing-library/react").MatcherOptions | undefined, waitForElementOptions?: import("@testing-library/react").waitForOptions | undefined) => Promise<HTMLElement[]>;
+};
+export declare function getInput(): HTMLElement;
+export {};

package/dist/hooks/useCombobox/__tests__/utils/renderUseCombobox.d.ts

@@ -0,0 +1,2 @@
+import { UseComboboxProps } from '../../index.types';
+export declare function renderUseCombobox(props?: Partial<UseComboboxProps<string>>): import("@testing-library/react").RenderHookResult<import("../../index.types").UseComboboxReturnValue<string>, unknown>;

package/dist/hooks/useCombobox/index.d.ts

@@ -1,96 +1,6 @@
-export default useCombobox;
-declare function useCombobox(userProps?: {}): {
-    getItemProps: ({ item: itemProp, index: indexProp, refKey, ref, onMouseMove, onMouseDown, onClick, onPress, disabled: disabledProp, ...rest }?: {
-        item: any;
-        index: any;
-        refKey?: string | undefined;
-        ref: any;
-        onMouseMove: any;
-        onMouseDown: any;
-        onClick: any;
-        onPress: any;
-        disabled: any;
-    }) => {
-        onMouseMove: Function;
-        onMouseDown: Function;
-        'aria-disabled': boolean;
-        'aria-selected': boolean;
-        id: string;
-        role: string;
-    };
-    getLabelProps: (labelProps: any) => any;
-    getMenuProps: ({ onMouseLeave, refKey, ref, ...rest }?: {
-        onMouseLeave: any;
-        refKey?: string | undefined;
-        ref: any;
-    }, { suppressRefError }?: {
-        suppressRefError?: boolean | undefined;
-    }) => {
-        id: string;
-        role: string;
-        'aria-labelledby': string | undefined;
-        onMouseLeave: Function;
-    };
-    getInputProps: ({ onKeyDown, onChange, onInput, onBlur, onChangeText, onClick, refKey, ref, ...rest }?: {
-        onKeyDown: any;
-        onChange: any;
-        onInput: any;
-        onBlur: any;
-        onChangeText: any;
-        onClick: any;
-        refKey?: string | undefined;
-        ref: any;
-    }, { suppressRefError }?: {
-        suppressRefError?: boolean | undefined;
-    }) => {
-        onChange: Function;
-        onChangeText: Function;
-        'aria-activedescendant': string;
-        'aria-autocomplete': string;
-        'aria-controls': string;
-        'aria-expanded': any;
-        'aria-labelledby': string | undefined;
-        autoComplete: string;
-        id: string;
-        role: string;
-        value: any;
-    };
-    getToggleButtonProps: ({ onClick, onPress, refKey, ref, ...rest }?: {
-        onClick: any;
-        onPress: any;
-        refKey?: string | undefined;
-        ref: any;
-    }) => {
-        'aria-controls': string;
-        'aria-expanded': any;
-        id: string;
-        tabIndex: number;
-    } | {
-        onPress: Function;
-        'aria-controls': string;
-        'aria-expanded': any;
-        id: string;
-        tabIndex: number;
-    } | {
-        onClick: Function;
-        'aria-controls': string;
-        'aria-expanded': any;
-        id: string;
-        tabIndex: number;
-    };
-    toggleMenu: () => void;
-    openMenu: () => void;
-    closeMenu: () => void;
-    setHighlightedIndex: (newHighlightedIndex: any) => void;
-    setInputValue: (newInputValue: any) => void;
-    selectItem: (newSelectedItem: any) => void;
-    reset: () => void;
-    highlightedIndex: any;
-    isOpen: any;
-    selectedItem: any;
-    inputValue: any;
-};
+import { UseComboboxProps, UseComboboxReturnValue } from './index.types';
+declare function useCombobox<Item>(userProps?: UseComboboxProps<Item>): UseComboboxReturnValue<Item>;
 declare namespace useCombobox {
-    export { stateChangeTypes };
+    var stateChangeTypes: typeof import("./stateChangeTypes");
 }
-import * as stateChangeTypes from "./stateChangeTypes";
+export default useCombobox;

package/dist/hooks/useCombobox/index.types.d.ts

@@ -0,0 +1,302 @@
+import { Environment, GetPropsCommonOptions, Overwrite } from '../../downshift.types';
+export interface UseComboboxState<Item> {
+    highlightedIndex: number;
+    selectedItem: Item | null;
+    isOpen: boolean;
+    inputValue: string;
+}
+export declare enum UseComboboxStateChangeTypes {
+    InputKeyDownArrowDown = "__input_keydown_arrow_down__",
+    InputKeyDownArrowUp = "__input_keydown_arrow_up__",
+    InputKeyDownEscape = "__input_keydown_escape__",
+    InputKeyDownHome = "__input_keydown_home__",
+    InputKeyDownEnd = "__input_keydown_end__",
+    InputKeyDownPageUp = "__input_keydown_page_up__",
+    InputKeyDownPageDown = "__input_keydown_page_down__",
+    InputKeyDownEnter = "__input_keydown_enter__",
+    InputChange = "__input_change__",
+    InputBlur = "__input_blur__",
+    InputClick = "__input_click__",
+    MenuMouseLeave = "__menu_mouse_leave__",
+    ItemMouseMove = "__item_mouse_move__",
+    ItemClick = "__item_click__",
+    ToggleButtonClick = "__togglebutton_click__",
+    FunctionToggleMenu = "__function_toggle_menu__",
+    FunctionOpenMenu = "__function_open_menu__",
+    FunctionCloseMenu = "__function_close_menu__",
+    FunctionSetHighlightedIndex = "__function_set_highlighted_index__",
+    FunctionSelectItem = "__function_select_item__",
+    FunctionSetInputValue = "__function_set_input_value__",
+    FunctionReset = "__function_reset__",
+    ControlledPropUpdatedSelectedItem = "__controlled_prop_updated_selected_item__"
+}
+export type UseComboboxInputKeyDownArrowDownAction = {
+    type: UseComboboxStateChangeTypes.InputKeyDownArrowDown;
+    altKey: boolean;
+};
+export type UseComboboxInputKeyDownArrowUpAction = {
+    type: UseComboboxStateChangeTypes.InputKeyDownArrowUp;
+    altKey: boolean;
+};
+export type UseComboboxInputKeyDownHomeAction = {
+    type: UseComboboxStateChangeTypes.InputKeyDownHome;
+};
+export type UseComboboxInputKeyDownEndAction = {
+    type: UseComboboxStateChangeTypes.InputKeyDownEnd;
+};
+export type UseComboboxInputKeyDownEscapeAction = {
+    type: UseComboboxStateChangeTypes.InputKeyDownEscape;
+};
+export type UseComboboxInputKeyDownEnterAction = {
+    type: UseComboboxStateChangeTypes.InputKeyDownEnter;
+};
+export type UseComboboxInputKeyDownPageUpAction = {
+    type: UseComboboxStateChangeTypes.InputKeyDownPageUp;
+};
+export type UseComboboxInputKeyDownPageDownAction = {
+    type: UseComboboxStateChangeTypes.InputKeyDownPageDown;
+};
+export type UseComboboxInputChangeAction = {
+    type: UseComboboxStateChangeTypes.InputChange;
+    inputValue: string;
+};
+export type UseComboboxInputBlurAction = {
+    type: UseComboboxStateChangeTypes.InputBlur;
+    selectItem?: boolean;
+};
+export type UseComboboxInputClickAction = {
+    type: UseComboboxStateChangeTypes.InputClick;
+};
+export type UseComboboxMenuMouseLeaveAction = {
+    type: UseComboboxStateChangeTypes.MenuMouseLeave;
+};
+export type UseComboboxItemMouseMoveAction = {
+    type: UseComboboxStateChangeTypes.ItemMouseMove;
+    index: number;
+    disabled: boolean;
+};
+export type UseComboboxItemClickAction = {
+    type: UseComboboxStateChangeTypes.ItemClick;
+    index: number;
+};
+export type UseComboboxToggleButtonClickAction = {
+    type: UseComboboxStateChangeTypes.ToggleButtonClick;
+};
+export type UseComboboxFunctionToggleMenuAction = {
+    type: UseComboboxStateChangeTypes.FunctionToggleMenu;
+};
+export type UseComboboxFunctionOpenMenuAction = {
+    type: UseComboboxStateChangeTypes.FunctionOpenMenu;
+};
+export type UseComboboxFunctionCloseMenuAction = {
+    type: UseComboboxStateChangeTypes.FunctionCloseMenu;
+};
+export type UseComboboxFunctionSetHighlightedIndexAction = {
+    type: UseComboboxStateChangeTypes.FunctionSetHighlightedIndex;
+    highlightedIndex: number;
+};
+export type UseComboboxFunctionSelectItemAction<Item> = {
+    type: UseComboboxStateChangeTypes.FunctionSelectItem;
+    selectedItem: Item | null;
+};
+export type UseComboboxFunctionSetInputValueAction = {
+    type: UseComboboxStateChangeTypes.FunctionSetInputValue;
+    inputValue: string;
+};
+export type UseComboboxFunctionResetAction = {
+    type: UseComboboxStateChangeTypes.FunctionReset;
+};
+export type UseComboboxControlledPropUpdatedSelectedItemAction = {
+    type: UseComboboxStateChangeTypes.ControlledPropUpdatedSelectedItem;
+    inputValue: string;
+};
+export type UseComboboxReducerAction<Item> = UseComboboxInputKeyDownArrowDownAction | UseComboboxInputKeyDownArrowUpAction | UseComboboxInputKeyDownHomeAction | UseComboboxInputKeyDownEndAction | UseComboboxInputKeyDownEscapeAction | UseComboboxInputKeyDownEnterAction | UseComboboxInputKeyDownPageUpAction | UseComboboxInputKeyDownPageDownAction | UseComboboxInputChangeAction | UseComboboxInputBlurAction | UseComboboxInputClickAction | UseComboboxMenuMouseLeaveAction | UseComboboxItemMouseMoveAction | UseComboboxItemClickAction | UseComboboxToggleButtonClickAction | UseComboboxFunctionToggleMenuAction | UseComboboxFunctionOpenMenuAction | UseComboboxFunctionCloseMenuAction | UseComboboxFunctionSetHighlightedIndexAction | UseComboboxFunctionSelectItemAction<Item> | UseComboboxFunctionSetInputValueAction | UseComboboxFunctionResetAction | UseComboboxControlledPropUpdatedSelectedItemAction;
+export interface UseComboboxProps<Item> {
+    items: Item[];
+    isItemDisabled?(item: Item, index: number): boolean;
+    itemToString?: (item: Item | null) => string;
+    itemToKey?: (item: Item | null) => any;
+    getA11yStatusMessage?: (options: UseComboboxState<Item>) => string;
+    highlightedIndex?: number;
+    initialHighlightedIndex?: number;
+    defaultHighlightedIndex?: number;
+    isOpen?: boolean;
+    initialIsOpen?: boolean;
+    defaultIsOpen?: boolean;
+    selectedItem?: Item | null;
+    initialSelectedItem?: Item | null;
+    defaultSelectedItem?: Item | null;
+    inputValue?: string;
+    initialInputValue?: string;
+    defaultInputValue?: string;
+    id?: string;
+    labelId?: string;
+    menuId?: string;
+    toggleButtonId?: string;
+    inputId?: string;
+    getItemId?: (index: number) => string;
+    scrollIntoView?: (node: HTMLElement, menuNode: HTMLElement) => void;
+    stateReducer?: (state: UseComboboxState<Item>, actionAndChanges: UseComboboxStateChangeOptions<Item>) => Partial<UseComboboxState<Item>>;
+    onSelectedItemChange?: (changes: UseComboboxSelectedItemChange<Item>) => void;
+    onIsOpenChange?: (changes: UseComboboxIsOpenChange<Item>) => void;
+    onHighlightedIndexChange?: (changes: UseComboboxHighlightedIndexChange<Item>) => void;
+    onStateChange?: (changes: UseComboboxStateChange<Item>) => void;
+    onInputValueChange?: (changes: UseComboboxInputValueChange<Item>) => void;
+    environment?: Environment;
+}
+export type UseComboboxMergedProps<Item> = Omit<UseComboboxProps<Item>, 'itemToString' | 'itemToKey' | 'stateReducer' | 'scrollIntoView' | 'isItemDisabled'> & Required<Pick<UseComboboxProps<Item>, 'itemToString' | 'itemToKey' | 'stateReducer' | 'scrollIntoView' | 'isItemDisabled'>>;
+export interface UseComboboxStateChangeOptions<Item> extends UseComboboxDispatchAction<Item> {
+    changes: Partial<UseComboboxState<Item>>;
+    props: UseComboboxMergedProps<Item>;
+}
+export interface UseComboboxDispatchAction<Item> {
+    type: UseComboboxStateChangeTypes;
+    altKey?: boolean;
+    inputValue?: string;
+    index?: number;
+    highlightedIndex?: number;
+    selectedItem?: Item | null;
+    selectItem?: boolean;
+}
+export interface UseComboboxStateChange<Item> extends Partial<UseComboboxState<Item>> {
+    type: UseComboboxStateChangeTypes;
+}
+export interface UseComboboxSelectedItemChange<Item> extends UseComboboxStateChange<Item> {
+    selectedItem: Item | null;
+}
+export interface UseComboboxHighlightedIndexChange<Item> extends UseComboboxStateChange<Item> {
+    highlightedIndex: number;
+}
+export interface UseComboboxIsOpenChange<Item> extends UseComboboxStateChange<Item> {
+    isOpen: boolean;
+}
+export interface UseComboboxInputValueChange<Item> extends UseComboboxStateChange<Item> {
+    inputValue: string;
+}
+export interface UseComboboxGetMenuPropsOptions extends React.HTMLProps<HTMLElement> {
+    refKey?: string;
+    ref?: React.Ref<any>;
+}
+export interface UseComboboxGetMenuPropsReturnValue {
+    'aria-label': string | undefined;
+    'aria-labelledby': string | undefined;
+    ref?: React.Ref<any>;
+    role: 'listbox';
+    id: string;
+    onMouseLeave: React.MouseEventHandler;
+}
+export type UseComboboxGetMenuProps = <Options>(options?: UseComboboxGetMenuPropsOptions & Options, otherOptions?: GetPropsCommonOptions) => Overwrite<UseComboboxGetMenuPropsReturnValue, Options>;
+export interface UseComboboxGetToggleButtonPropsOptions extends React.HTMLProps<HTMLElement> {
+    disabled?: boolean;
+    refKey?: string;
+    ref?: React.Ref<any>;
+    onPress?: (event: React.BaseSyntheticEvent) => void;
+}
+export interface UseComboboxGetToggleButtonPropsReturnValue {
+    'aria-controls': string;
+    'aria-expanded': boolean;
+    id: string;
+    onPress?: (event: React.BaseSyntheticEvent) => void;
+    onClick?: React.MouseEventHandler;
+    ref?: React.Ref<any>;
+    tabIndex: -1;
+}
+export type UseComboboxGetToggleButtonProps = <Options>(options?: UseComboboxGetToggleButtonPropsOptions & Options) => Overwrite<UseComboboxGetToggleButtonPropsReturnValue, Options>;
+export interface UseComboboxGetLabelPropsOptions extends React.HTMLProps<HTMLElement> {
+}
+export interface UseComboboxGetLabelPropsReturnValue {
+    htmlFor: string;
+    id: string;
+}
+export type UseComboboxGetLabelProps = <Options>(options?: UseComboboxGetLabelPropsOptions & Options) => Overwrite<UseComboboxGetLabelPropsReturnValue, Options>;
+export interface UseComboboxGetItemPropsOptions<Item> extends React.HTMLProps<HTMLElement> {
+    index?: number;
+    item?: Item;
+    refKey?: string;
+    ref?: React.Ref<any>;
+    onPress?: (event: React.BaseSyntheticEvent) => void;
+}
+export interface UseComboboxGetItemPropsReturnValue {
+    'aria-selected': boolean;
+    'aria-disabled': boolean;
+    id: string;
+    onClick?: React.MouseEventHandler;
+    onMouseDown?: React.MouseEventHandler;
+    onMouseMove?: React.MouseEventHandler;
+    onPress?: React.MouseEventHandler;
+    ref?: React.Ref<any>;
+    role: 'option';
+}
+export type UseComboboxGetItemProps<Item> = <Options>(options?: UseComboboxGetItemPropsOptions<Item> & Options) => Omit<Overwrite<UseComboboxGetItemPropsReturnValue, Options>, 'index' | 'item'>;
+export interface UseComboboxGetInputPropsOptions extends React.HTMLProps<HTMLInputElement> {
+    refKey?: string;
+    ref?: React.Ref<HTMLInputElement>;
+    onChangeText?: (event: React.BaseSyntheticEvent) => void;
+}
+export interface UseComboboxGetInputPropsReturnValue {
+    ref?: React.Ref<any>;
+    'aria-activedescendant': string;
+    'aria-autocomplete': 'list';
+    'aria-controls': string;
+    'aria-expanded': boolean;
+    'aria-labelledby': string | undefined;
+    'aria-label': string | undefined;
+    autoComplete: 'off';
+    disabled: boolean | undefined;
+    id: string;
+    role: 'combobox';
+    value: string;
+    onBlur?: React.FocusEventHandler;
+    onChange?: React.ChangeEventHandler;
+    onChangeText?: React.ChangeEventHandler;
+    onClick?: React.MouseEventHandler;
+    onInput?: React.FormEventHandler;
+    onKeyDown?: React.KeyboardEventHandler;
+}
+export type UseComboboxGetInputProps = <Options>(options?: UseComboboxGetInputPropsOptions & Options, otherOptions?: GetPropsCommonOptions) => Overwrite<UseComboboxGetInputPropsReturnValue, Options>;
+export interface UseComboboxPropGetters<Item> {
+    getToggleButtonProps: UseComboboxGetToggleButtonProps;
+    getLabelProps: UseComboboxGetLabelProps;
+    getMenuProps: UseComboboxGetMenuProps;
+    getItemProps: UseComboboxGetItemProps<Item>;
+    getInputProps: UseComboboxGetInputProps;
+}
+export interface UseComboboxActions<Item> {
+    reset: () => void;
+    openMenu: () => void;
+    closeMenu: () => void;
+    toggleMenu: () => void;
+    selectItem: (item: Item | null) => void;
+    setHighlightedIndex: (index: number) => void;
+    setInputValue: (inputValue: string) => void;
+}
+export type UseComboboxReturnValue<Item> = UseComboboxState<Item> & UseComboboxPropGetters<Item> & UseComboboxActions<Item>;
+export interface UseComboboxInterface {
+    <Item>(props: UseComboboxProps<Item>): UseComboboxReturnValue<Item>;
+    stateChangeTypes: {
+        InputKeyDownArrowDown: UseComboboxStateChangeTypes.InputKeyDownArrowDown;
+        InputKeyDownArrowUp: UseComboboxStateChangeTypes.InputKeyDownArrowUp;
+        InputKeyDownEscape: UseComboboxStateChangeTypes.InputKeyDownEscape;
+        InputKeyDownHome: UseComboboxStateChangeTypes.InputKeyDownHome;
+        InputKeyDownEnd: UseComboboxStateChangeTypes.InputKeyDownEnd;
+        InputKeyDownPageDown: UseComboboxStateChangeTypes.InputKeyDownPageDown;
+        InputKeyDownPageUp: UseComboboxStateChangeTypes.InputKeyDownPageUp;
+        InputKeyDownEnter: UseComboboxStateChangeTypes.InputKeyDownEnter;
+        InputChange: UseComboboxStateChangeTypes.InputChange;
+        InputBlur: UseComboboxStateChangeTypes.InputBlur;
+        InputClick: UseComboboxStateChangeTypes.InputClick;
+        MenuMouseLeave: UseComboboxStateChangeTypes.MenuMouseLeave;
+        ItemMouseMove: UseComboboxStateChangeTypes.ItemMouseMove;
+        ItemClick: UseComboboxStateChangeTypes.ItemClick;
+        ToggleButtonClick: UseComboboxStateChangeTypes.ToggleButtonClick;
+        FunctionToggleMenu: UseComboboxStateChangeTypes.FunctionToggleMenu;
+        FunctionOpenMenu: UseComboboxStateChangeTypes.FunctionOpenMenu;
+        FunctionCloseMenu: UseComboboxStateChangeTypes.FunctionCloseMenu;
+        FunctionSetHighlightedIndex: UseComboboxStateChangeTypes.FunctionSetHighlightedIndex;
+        FunctionSelectItem: UseComboboxStateChangeTypes.FunctionSelectItem;
+        FunctionSetInputValue: UseComboboxStateChangeTypes.FunctionSetInputValue;
+        FunctionReset: UseComboboxStateChangeTypes.FunctionReset;
+        ControlledPropUpdatedSelectedItem: UseComboboxStateChangeTypes.ControlledPropUpdatedSelectedItem;
+    };
+}
+export declare const useCombobox: UseComboboxInterface;

package/dist/hooks/useCombobox/reducer.d.ts

@@ -1 +1,4 @@
-export default function downshiftUseComboboxReducer(state: any, props: any, action: any): any;
+import { UseComboboxMergedProps, UseComboboxReducerAction, UseComboboxState } from './index.types';
+export default function downshiftUseComboboxReducer<Item>(state: UseComboboxState<Item>, action: UseComboboxReducerAction<Item> & {
+    props: UseComboboxMergedProps<Item>;
+}): UseComboboxState<Item>;

package/dist/hooks/useCombobox/stateChangeTypes.d.ts

@@ -1,23 +1,24 @@
-export const InputKeyDownArrowDown: "__input_keydown_arrow_down__";
-export const InputKeyDownArrowUp: "__input_keydown_arrow_up__";
-export const InputKeyDownEscape: "__input_keydown_escape__";
-export const InputKeyDownHome: "__input_keydown_home__";
-export const InputKeyDownEnd: "__input_keydown_end__";
-export const InputKeyDownPageUp: "__input_keydown_page_up__";
-export const InputKeyDownPageDown: "__input_keydown_page_down__";
-export const InputKeyDownEnter: "__input_keydown_enter__";
-export const InputChange: "__input_change__";
-export const InputBlur: "__input_blur__";
-export const InputClick: "__input_click__";
-export const MenuMouseLeave: "__menu_mouse_leave__";
-export const ItemMouseMove: "__item_mouse_move__";
-export const ItemClick: "__item_click__";
-export const ToggleButtonClick: "__togglebutton_click__";
-export const FunctionToggleMenu: "__function_toggle_menu__";
-export const FunctionOpenMenu: "__function_open_menu__";
-export const FunctionCloseMenu: "__function_close_menu__";
-export const FunctionSetHighlightedIndex: "__function_set_highlighted_index__";
-export const FunctionSelectItem: "__function_select_item__";
-export const FunctionSetInputValue: "__function_set_input_value__";
-export const FunctionReset: "__function_reset__";
-export const ControlledPropUpdatedSelectedItem: "__controlled_prop_updated_selected_item__";
+import { UseComboboxStateChangeTypes } from './index.types';
+export declare const InputKeyDownArrowDown: UseComboboxStateChangeTypes.InputKeyDownArrowDown;
+export declare const InputKeyDownArrowUp: UseComboboxStateChangeTypes.InputKeyDownArrowUp;
+export declare const InputKeyDownEscape: UseComboboxStateChangeTypes.InputKeyDownEscape;
+export declare const InputKeyDownHome: UseComboboxStateChangeTypes.InputKeyDownHome;
+export declare const InputKeyDownEnd: UseComboboxStateChangeTypes.InputKeyDownEnd;
+export declare const InputKeyDownPageUp: UseComboboxStateChangeTypes.InputKeyDownPageUp;
+export declare const InputKeyDownPageDown: UseComboboxStateChangeTypes.InputKeyDownPageDown;
+export declare const InputKeyDownEnter: UseComboboxStateChangeTypes.InputKeyDownEnter;
+export declare const InputChange: UseComboboxStateChangeTypes.InputChange;
+export declare const InputBlur: UseComboboxStateChangeTypes.InputBlur;
+export declare const InputClick: UseComboboxStateChangeTypes.InputClick;
+export declare const MenuMouseLeave: UseComboboxStateChangeTypes.MenuMouseLeave;
+export declare const ItemMouseMove: UseComboboxStateChangeTypes.ItemMouseMove;
+export declare const ItemClick: UseComboboxStateChangeTypes.ItemClick;
+export declare const ToggleButtonClick: UseComboboxStateChangeTypes.ToggleButtonClick;
+export declare const FunctionToggleMenu: UseComboboxStateChangeTypes.FunctionToggleMenu;
+export declare const FunctionOpenMenu: UseComboboxStateChangeTypes.FunctionOpenMenu;
+export declare const FunctionCloseMenu: UseComboboxStateChangeTypes.FunctionCloseMenu;
+export declare const FunctionSetHighlightedIndex: UseComboboxStateChangeTypes.FunctionSetHighlightedIndex;
+export declare const FunctionSelectItem: UseComboboxStateChangeTypes.FunctionSelectItem;
+export declare const FunctionSetInputValue: UseComboboxStateChangeTypes.FunctionSetInputValue;
+export declare const FunctionReset: UseComboboxStateChangeTypes.FunctionReset;
+export declare const ControlledPropUpdatedSelectedItem: UseComboboxStateChangeTypes.ControlledPropUpdatedSelectedItem;

package/dist/hooks/useCombobox/utils/getInitialState.d.ts

@@ -0,0 +1,10 @@
+import { GetInitialStateProps as GetInitialStatePropsCommon } from '../../utils';
+export type GetInitialStateProps<T> = GetInitialStatePropsCommon<T> & {
+    itemToString: (item: T) => string;
+};
+export declare function getInitialState<T>(props: GetInitialStateProps<T>): {
+    inputValue: string;
+    highlightedIndex: number;
+    isOpen: boolean;
+    selectedItem: T | null;
+};

package/dist/hooks/useCombobox/utils/index.d.ts

@@ -0,0 +1,3 @@
+export { getInitialState } from './getInitialState';
+export { useControlledReducer } from './useControlledReducer';
+export { propTypes } from './propTypes';