downshift 9.3.2 → 9.4.0-alpha.0

package/dist/hooks/useCombobox/{utils.d.ts → utils/propTypes.d.ts}

@@ -1,24 +1,5 @@
-export function getInitialState(props: any): {
-    inputValue: unknown;
-    highlightedIndex: any;
-    isOpen: unknown;
-    selectedItem: unknown;
-};
-/**
- * The useCombobox version of useControlledReducer, which also
- * checks if the controlled prop selectedItem changed between
- * renders. If so, it will also update inputValue with its
- * string equivalent. It uses the common useEnhancedReducer to
- * compute the rest of the state.
- *
- * @param {Function} reducer Reducer function from downshift.
- * @param {Object} props The hook props, also passed to createInitialState.
- * @param {Function} createInitialState Function that returns the initial state.
- * @param {Function} isStateEqual Function that checks if a previous state is equal to the next.
- * @returns {Array} An array with the state and an action dispatcher.
- */
-export function useControlledReducer(reducer: Function, props: Object, createInitialState: Function, isStateEqual: Function): any[];
-export const propTypes: {
+import PropTypes from 'prop-types';
+export declare const propTypes: {
     items: PropTypes.Validator<any[]>;
     isItemDisabled: PropTypes.Requireable<(...args: any[]) => any>;
     inputValue: PropTypes.Requireable<string>;
@@ -60,12 +41,3 @@ export const propTypes: {
     itemToKey: PropTypes.Requireable<(...args: any[]) => any>;
     stateReducer: PropTypes.Requireable<(...args: any[]) => any>;
 };
-export const defaultProps: {
-    isItemDisabled(): boolean;
-    itemToString(item: unknown): string;
-    itemToKey(item: unknown): unknown;
-    stateReducer: typeof import("../utils-ts").stateReducer;
-    scrollIntoView: typeof import("../../utils-ts").scrollIntoView;
-    environment: (Window & typeof globalThis) | undefined;
-};
-import PropTypes from "prop-types";

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

@@ -0,0 +1,16 @@
+import { Reducer } from '../../utils';
+import { UseComboboxMergedProps, UseComboboxReducerAction, UseComboboxState } from '../index.types';
+/**
+ * The useCombobox version of useControlledReducer, which also
+ * checks if the controlled prop selectedItem changed between
+ * renders. If so, it will also update inputValue with its
+ * string equivalent. It uses the common useEnhancedReducer to
+ * compute the rest of the state.
+ *
+ * @param reducer Reducer function from downshift.
+ * @param props The hook props, also passed to createInitialState.
+ * @param createInitialState Function that returns the initial state.
+ * @param isStateEqual Function that checks if a previous state is equal to the next.
+ * @returns An array with the state and an action dispatcher.
+ */
+export declare function useControlledReducer<Item>(reducer: Reducer<UseComboboxState<Item>, UseComboboxReducerAction<Item>>, props: UseComboboxMergedProps<Item>, createInitialState: (props: UseComboboxMergedProps<Item>) => UseComboboxState<Item>, isStateEqual: (prev: UseComboboxState<Item>, next: UseComboboxState<Item>) => boolean): [UseComboboxState<Item>, (action: UseComboboxReducerAction<Item>) => void];

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

@@ -2,27 +2,39 @@ export default useMultipleSelection;
 declare function useMultipleSelection(userProps?: {}): {
     getSelectedItemProps: ({ refKey, ref, onClick, onKeyDown, selectedItem: selectedItemProp, index: indexProp, ...rest }?: {
         refKey?: string | undefined;
-        ref: any;
-        onClick: any;
-        onKeyDown: any;
-        selectedItem: any;
-        index: any;
     }) => {
         tabIndex: number;
-        onClick: Function;
-        onKeyDown: Function;
+        onClick: (event: React.SyntheticEvent & {
+            preventDownshiftDefault?: boolean;
+            nativeEvent: {
+                preventDownshiftDefault?: boolean;
+            };
+        }, ...args: unknown[]) => boolean;
+        onKeyDown: (event: React.SyntheticEvent & {
+            preventDownshiftDefault?: boolean;
+            nativeEvent: {
+                preventDownshiftDefault?: boolean;
+            };
+        }, ...args: unknown[]) => boolean;
     };
     getDropdownProps: ({ refKey, ref, onKeyDown, onClick, preventKeyAction, ...rest }?: {
         refKey?: string | undefined;
-        ref: any;
-        onKeyDown: any;
-        onClick: any;
         preventKeyAction?: boolean | undefined;
     }, { suppressRefError }?: {
         suppressRefError?: boolean | undefined;
     }) => {
-        onKeyDown?: Function | undefined;
-        onClick?: Function | undefined;
+        onKeyDown?: ((event: React.SyntheticEvent & {
+            preventDownshiftDefault?: boolean;
+            nativeEvent: {
+                preventDownshiftDefault?: boolean;
+            };
+        }, ...args: unknown[]) => boolean) | undefined;
+        onClick?: ((event: React.SyntheticEvent & {
+            preventDownshiftDefault?: boolean;
+            nativeEvent: {
+                preventDownshiftDefault?: boolean;
+            };
+        }, ...args: unknown[]) => boolean) | undefined;
     };
     addSelectedItem: (selectedItem: any) => void;
     removeSelectedItem: (selectedItem: any) => void;
@@ -35,4 +47,4 @@ declare function useMultipleSelection(userProps?: {}): {
 declare namespace useMultipleSelection {
     export { stateChangeTypes };
 }
-import * as stateChangeTypes from "./stateChangeTypes";
+import * as stateChangeTypes from './stateChangeTypes';

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

@@ -0,0 +1,117 @@
+import * as React from 'react';
+import { Environment, GetPropsCommonOptions, Overwrite } from '../../downshift.types';
+export interface UseMultipleSelectionState<Item> {
+    selectedItems: Item[];
+    activeIndex: number;
+}
+export declare enum UseMultipleSelectionStateChangeTypes {
+    SelectedItemClick = "__selected_item_click__",
+    SelectedItemKeyDownDelete = "__selected_item_keydown_delete__",
+    SelectedItemKeyDownBackspace = "__selected_item_keydown_backspace__",
+    SelectedItemKeyDownNavigationNext = "__selected_item_keydown_navigation_next__",
+    SelectedItemKeyDownNavigationPrevious = "__selected_item_keydown_navigation_previous__",
+    DropdownKeyDownNavigationPrevious = "__dropdown_keydown_navigation_previous__",
+    DropdownKeyDownBackspace = "__dropdown_keydown_backspace__",
+    DropdownClick = "__dropdown_click__",
+    FunctionAddSelectedItem = "__function_add_selected_item__",
+    FunctionRemoveSelectedItem = "__function_remove_selected_item__",
+    FunctionSetSelectedItems = "__function_set_selected_items__",
+    FunctionSetActiveIndex = "__function_set_active_index__",
+    FunctionReset = "__function_reset__"
+}
+export interface UseMultipleSelectionProps<Item> {
+    selectedItems?: Item[];
+    initialSelectedItems?: Item[];
+    defaultSelectedItems?: Item[];
+    itemToKey?: (item: Item | null) => any;
+    getA11yStatusMessage?: (options: UseMultipleSelectionState<Item>) => string;
+    stateReducer?: (state: UseMultipleSelectionState<Item>, actionAndChanges: UseMultipleSelectionStateChangeOptions<Item>) => Partial<UseMultipleSelectionState<Item>>;
+    activeIndex?: number;
+    initialActiveIndex?: number;
+    defaultActiveIndex?: number;
+    onActiveIndexChange?: (changes: UseMultipleSelectionActiveIndexChange<Item>) => void;
+    onSelectedItemsChange?: (changes: UseMultipleSelectionSelectedItemsChange<Item>) => void;
+    onStateChange?: (changes: UseMultipleSelectionStateChange<Item>) => void;
+    keyNavigationNext?: string;
+    keyNavigationPrevious?: string;
+    environment?: Environment;
+}
+export interface UseMultipleSelectionStateChangeOptions<Item> extends UseMultipleSelectionDispatchAction<Item> {
+    changes: Partial<UseMultipleSelectionState<Item>>;
+}
+export interface UseMultipleSelectionDispatchAction<Item> {
+    type: UseMultipleSelectionStateChangeTypes;
+    index?: number;
+    selectedItem?: Item | null;
+    selectedItems?: Item[];
+    activeIndex?: number;
+}
+export interface UseMultipleSelectionStateChange<Item> extends Partial<UseMultipleSelectionState<Item>> {
+    type: UseMultipleSelectionStateChangeTypes;
+}
+export interface UseMultipleSelectionActiveIndexChange<Item> extends UseMultipleSelectionStateChange<Item> {
+    activeIndex: number;
+}
+export interface UseMultipleSelectionSelectedItemsChange<Item> extends UseMultipleSelectionStateChange<Item> {
+    selectedItems: Item[];
+}
+export interface A11yRemovalMessage<Item> {
+    itemToString: (item: Item) => string;
+    resultCount: number;
+    activeSelectedItem: Item;
+    removedSelectedItem: Item;
+    activeIndex: number;
+}
+export interface UseMultipleSelectionGetSelectedItemPropsOptions<Item> extends React.HTMLProps<HTMLElement> {
+    refKey?: string;
+    ref?: React.Ref<any>;
+    index?: number;
+    selectedItem: Item;
+}
+export interface UseMultipleSelectionGetSelectedItemReturnValue {
+    ref?: React.Ref<any>;
+    tabIndex: 0 | -1;
+    onClick: React.MouseEventHandler;
+    onKeyDown: React.KeyboardEventHandler;
+}
+export interface UseMultipleSelectionGetDropdownPropsOptions extends React.HTMLProps<HTMLElement> {
+    preventKeyAction?: boolean;
+    refKey?: string;
+    ref?: React.Ref<any>;
+}
+export interface UseMultipleSelectionGetDropdownReturnValue {
+    ref?: React.Ref<any>;
+    onClick?: React.MouseEventHandler;
+    onKeyDown?: React.KeyboardEventHandler;
+}
+export interface UseMultipleSelectionPropGetters<Item> {
+    getDropdownProps: <Options>(options?: UseMultipleSelectionGetDropdownPropsOptions & Options, extraOptions?: GetPropsCommonOptions) => Omit<Overwrite<UseMultipleSelectionGetDropdownReturnValue, Options>, 'preventKeyAction'>;
+    getSelectedItemProps: <Options>(options: UseMultipleSelectionGetSelectedItemPropsOptions<Item> & Options) => Omit<Overwrite<UseMultipleSelectionGetSelectedItemReturnValue, Options>, 'index' | 'selectedItem'>;
+}
+export interface UseMultipleSelectionActions<Item> {
+    reset: () => void;
+    addSelectedItem: (item: Item) => void;
+    removeSelectedItem: (item: Item) => void;
+    setSelectedItems: (items: Item[]) => void;
+    setActiveIndex: (index: number) => void;
+}
+export type UseMultipleSelectionReturnValue<Item> = UseMultipleSelectionState<Item> & UseMultipleSelectionPropGetters<Item> & UseMultipleSelectionActions<Item>;
+export interface UseMultipleSelectionInterface {
+    <Item>(props?: UseMultipleSelectionProps<Item>): UseMultipleSelectionReturnValue<Item>;
+    stateChangeTypes: {
+        SelectedItemClick: UseMultipleSelectionStateChangeTypes.SelectedItemClick;
+        SelectedItemKeyDownDelete: UseMultipleSelectionStateChangeTypes.SelectedItemKeyDownDelete;
+        SelectedItemKeyDownBackspace: UseMultipleSelectionStateChangeTypes.SelectedItemKeyDownBackspace;
+        SelectedItemKeyDownNavigationNext: UseMultipleSelectionStateChangeTypes.SelectedItemKeyDownNavigationNext;
+        SelectedItemKeyDownNavigationPrevious: UseMultipleSelectionStateChangeTypes.SelectedItemKeyDownNavigationPrevious;
+        DropdownKeyDownNavigationPrevious: UseMultipleSelectionStateChangeTypes.DropdownKeyDownNavigationPrevious;
+        DropdownKeyDownBackspace: UseMultipleSelectionStateChangeTypes.DropdownKeyDownBackspace;
+        DropdownClick: UseMultipleSelectionStateChangeTypes.DropdownClick;
+        FunctionAddSelectedItem: UseMultipleSelectionStateChangeTypes.FunctionAddSelectedItem;
+        FunctionRemoveSelectedItem: UseMultipleSelectionStateChangeTypes.FunctionRemoveSelectedItem;
+        FunctionSetSelectedItems: UseMultipleSelectionStateChangeTypes.FunctionSetSelectedItems;
+        FunctionSetActiveIndex: UseMultipleSelectionStateChangeTypes.FunctionSetActiveIndex;
+        FunctionReset: UseMultipleSelectionStateChangeTypes.FunctionReset;
+    };
+}
+export declare const useMultipleSelection: UseMultipleSelectionInterface;

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

@@ -1 +1 @@
-export default function downshiftMultipleSelectionReducer(state: any, props: any, action: any): any;
+export default function downshiftMultipleSelectionReducer(state: any, action: any): any;

package/dist/hooks/useMultipleSelection/utils.d.ts

@@ -1,20 +1,19 @@
+export namespace defaultStateValues {
+    let activeIndex: number;
+    let selectedItems: never[];
+}
 export namespace defaultProps {
-    const itemToKey: (item: unknown) => unknown;
-    const stateReducer: typeof import("../utils-ts").stateReducer;
-    const environment: (Window & typeof globalThis) | undefined;
-    const keyNavigationNext: string;
-    const keyNavigationPrevious: string;
+    let itemToKey: (item: unknown) => unknown;
+    let stateReducer: <S, A>(_state: S, actionAndChanges: (A & {
+        props: any;
+    }) & {
+        changes: Partial<S>;
+    }) => Partial<S>;
+    let environment: (Window & typeof globalThis) | undefined;
+    let keyNavigationNext: string;
+    let keyNavigationPrevious: string;
 }
 export let validatePropTypes: typeof noop;
-/**
- * Returns the default value for a state key in the following order:
- * 1. controlled prop, 2. default prop, 3. default value from Downshift.
- *
- * @param {Object} props Props passed to the hook.
- * @param {string} propKey Props key to generate the value for.
- * @returns {any} The initial value for that prop.
- */
-export function getDefaultValue(props: Object, propKey: string): any;
 /**
  * Gets the initial state based on the provided props. It uses initial, default
  * and controlled props related to state in order to compute the initial value.
@@ -42,4 +41,4 @@ export function isKeyDownOperationPermitted(event: KeyboardEvent): boolean;
  * @returns {boolean} Wheather the states are deeply equal.
  */
 export function isStateEqual(prevState: Object, newState: Object): boolean;
-import { noop } from "../../utils-ts";
+import { noop } from '../../utils';

package/dist/hooks/useSelect/__tests__/utils/getItemIndexByCharacter.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Return the index of the item that starts with the character.
+ * @param character The start of the item string.
+ * @param startIndex The index to start searching.
+ * @returns The index of the item.
+ */
+export declare function getItemIndexByCharacter(character: string, startIndex?: number): number;

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

@@ -0,0 +1,6 @@
+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 { renderUseSelect } from './renderUseSelect';
+export { renderSelect } from './renderSelect';
+export { getItemIndexByCharacter } from './getItemIndexByCharacter';
+export { stateChangeTestCases } from './stateChangeTestCases';

package/dist/hooks/useSelect/__tests__/utils/renderSelect.d.ts

@@ -0,0 +1,71 @@
+import * as React from 'react';
+import { UseSelectProps, UseSelectGetItemProps } from '../../index.types';
+type DropdownSelectProps = Omit<UseSelectProps<string>, 'items'> & {
+    items?: string[];
+    renderSpy: jest.Mock;
+    renderItem?: (props: {
+        index: number;
+        item: string;
+        getItemProps: UseSelectGetItemProps<string>;
+        stringItem: string;
+    }) => React.ReactNode;
+};
+export declare function renderSelect(props: Omit<DropdownSelectProps, 'renderSpy'>, uiCallback?: (ui: React.ReactElement) => React.ReactElement): {
+    renderSpy: jest.Mock<any, any, any>;
+    rerender: (p: Omit<DropdownSelectProps, "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 {};

package/dist/hooks/useSelect/__tests__/utils/renderUseSelect.d.ts

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

package/dist/hooks/useSelect/__tests__/utils/stateChangeTestCases.d.ts

@@ -0,0 +1,182 @@
+import { clickOnItemAtIndex, clickOnToggleButton, keyDownOnToggleButton, mouseLeaveItemAtIndex, mouseMoveItemAtIndex, tab } from '../../../testUtils';
+export declare const stateChangeTestCases: ({
+    step: typeof keyDownOnToggleButton;
+    arg: string;
+    state: {
+        isOpen: boolean;
+        highlightedIndex: number;
+        inputValue: string;
+        selectedItem: null;
+    };
+    type: import("../../index.types").UseSelectStateChangeTypes.ToggleButtonClick;
+} | {
+    step: typeof keyDownOnToggleButton;
+    arg: string;
+    state: {
+        isOpen: boolean;
+        highlightedIndex: number;
+        inputValue: string;
+        selectedItem: null;
+    };
+    type: import("../../index.types").UseSelectStateChangeTypes.ToggleButtonKeyDownEnter;
+} | {
+    step: typeof keyDownOnToggleButton;
+    arg: string;
+    state: {
+        isOpen: boolean;
+        highlightedIndex: number;
+        inputValue: string;
+        selectedItem: null;
+    };
+    type: import("../../index.types").UseSelectStateChangeTypes.ToggleButtonKeyDownEscape;
+} | {
+    step: typeof keyDownOnToggleButton;
+    arg: string;
+    state: {
+        isOpen: boolean;
+        highlightedIndex: number;
+        inputValue: string;
+        selectedItem: null;
+    };
+    type: import("../../index.types").UseSelectStateChangeTypes.ToggleButtonKeyDownArrowDown;
+} | {
+    step: typeof keyDownOnToggleButton;
+    arg: string;
+    state: {
+        isOpen: boolean;
+        highlightedIndex: number;
+        inputValue: string;
+        selectedItem: string | undefined;
+    };
+    type: import("../../index.types").UseSelectStateChangeTypes.ToggleButtonKeyDownEnter;
+} | {
+    step: typeof keyDownOnToggleButton;
+    arg: string;
+    state: {
+        isOpen: boolean;
+        highlightedIndex: number;
+        inputValue: string;
+        selectedItem: string | undefined;
+    };
+    type: import("../../index.types").UseSelectStateChangeTypes.ToggleButtonKeyDownEnd;
+} | {
+    step: typeof keyDownOnToggleButton;
+    arg: string;
+    state: {
+        isOpen: boolean;
+        highlightedIndex: number;
+        inputValue: string;
+        selectedItem: string | undefined;
+    };
+    type: import("../../index.types").UseSelectStateChangeTypes.ToggleButtonKeyDownSpaceButton;
+} | {
+    step: typeof clickOnToggleButton;
+    state: {
+        isOpen: boolean;
+        highlightedIndex: number;
+        inputValue: string;
+        selectedItem: string | undefined;
+    };
+    type: import("../../index.types").UseSelectStateChangeTypes.ToggleButtonClick;
+    arg?: undefined;
+} | {
+    step: typeof keyDownOnToggleButton;
+    arg: string;
+    state: {
+        isOpen: boolean;
+        highlightedIndex: number;
+        inputValue: string;
+        selectedItem: string | undefined;
+    };
+    type: import("../../index.types").UseSelectStateChangeTypes.ToggleButtonKeyDownPageUp;
+} | {
+    step: typeof keyDownOnToggleButton;
+    arg: string;
+    state: {
+        isOpen: boolean;
+        highlightedIndex: number;
+        inputValue: string;
+        selectedItem: string | undefined;
+    };
+    type: import("../../index.types").UseSelectStateChangeTypes.ToggleButtonKeyDownPageDown;
+} | {
+    step: typeof mouseMoveItemAtIndex;
+    arg: number;
+    state: {
+        isOpen: boolean;
+        highlightedIndex: number;
+        inputValue: string;
+        selectedItem: string | undefined;
+    };
+    type: import("../../index.types").UseSelectStateChangeTypes.ItemMouseMove;
+} | {
+    step: typeof mouseLeaveItemAtIndex;
+    arg: number;
+    state: {
+        isOpen: boolean;
+        highlightedIndex: number;
+        inputValue: string;
+        selectedItem: string | undefined;
+    };
+    type: import("../../index.types").UseSelectStateChangeTypes.MenuMouseLeave;
+} | {
+    step: typeof clickOnItemAtIndex;
+    arg: number;
+    state: {
+        isOpen: boolean;
+        highlightedIndex: number;
+        inputValue: string;
+        selectedItem: string | undefined;
+    };
+    type: import("../../index.types").UseSelectStateChangeTypes.ItemClick;
+} | {
+    step: typeof keyDownOnToggleButton;
+    arg: string;
+    state: {
+        isOpen: boolean;
+        highlightedIndex: number;
+        inputValue: string;
+        selectedItem: string | undefined;
+    };
+    type: import("../../index.types").UseSelectStateChangeTypes.ToggleButtonKeyDownArrowDown;
+} | {
+    step: typeof keyDownOnToggleButton;
+    arg: string;
+    state: {
+        isOpen: boolean;
+        highlightedIndex: number;
+        inputValue: string;
+        selectedItem: string | undefined;
+    };
+    type: import("../../index.types").UseSelectStateChangeTypes.ToggleButtonKeyDownArrowUp;
+} | {
+    step: typeof keyDownOnToggleButton;
+    arg: string;
+    state: {
+        isOpen: boolean;
+        highlightedIndex: number;
+        inputValue: string;
+        selectedItem: string | undefined;
+    };
+    type: import("../../index.types").UseSelectStateChangeTypes.ToggleButtonKeyDownCharacter;
+} | {
+    step: () => Promise<void>;
+    state: {
+        isOpen: boolean;
+        highlightedIndex: number;
+        inputValue: string;
+        selectedItem: string | undefined;
+    };
+    type: import("../../index.types").UseSelectStateChangeTypes.FunctionSetInputValue;
+    arg?: undefined;
+} | {
+    step: typeof tab;
+    state: {
+        isOpen: boolean;
+        highlightedIndex: number;
+        inputValue: string;
+        selectedItem: string | undefined;
+    };
+    type: import("../../index.types").UseSelectStateChangeTypes.ToggleButtonBlur;
+    arg?: undefined;
+})[];

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

@@ -1,73 +1,6 @@
-export default useSelect;
-declare function useSelect(userProps?: {}): {
-    getToggleButtonProps: ({ onBlur, onClick, onPress, onKeyDown, refKey, ref, ...rest }?: {
-        onBlur: any;
-        onClick: any;
-        onPress: any;
-        onKeyDown: any;
-        refKey?: string | undefined;
-        ref: any;
-    }, { suppressRefError }?: {
-        suppressRefError?: boolean | undefined;
-    }) => {
-        'aria-activedescendant': string;
-        'aria-controls': string;
-        'aria-expanded': any;
-        'aria-haspopup': string;
-        'aria-labelledby': string | undefined;
-        id: string;
-        role: string;
-        tabIndex: number;
-        onBlur: Function;
-    };
-    getLabelProps: ({ onClick, ...labelProps }?: {
-        onClick: any;
-    }) => {
-        id: string;
-        htmlFor: string;
-        onClick: Function;
-    };
-    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;
-    };
-    getItemProps: ({ item: itemProp, index: indexProp, onMouseMove, onClick, onMouseDown, onPress, refKey, disabled: disabledProp, ref, ...rest }?: {
-        item: any;
-        index: any;
-        onMouseMove: any;
-        onClick: any;
-        onMouseDown: any;
-        onPress: any;
-        refKey?: string | undefined;
-        disabled: any;
-        ref: any;
-    }) => {
-        'aria-disabled': boolean;
-        'aria-selected': boolean;
-        id: string;
-        role: string;
-    };
-    toggleMenu: () => void;
-    openMenu: () => void;
-    closeMenu: () => void;
-    setHighlightedIndex: (newHighlightedIndex: any) => void;
-    selectItem: (newSelectedItem: any) => void;
-    reset: () => void;
-    setInputValue: (newInputValue: any) => void;
-    highlightedIndex: any;
-    isOpen: any;
-    selectedItem: any;
-    inputValue: any;
-};
+import { UseSelectProps, UseSelectReturnValue } from './index.types';
+declare function useSelect<Item>(userProps?: UseSelectProps<Item>): UseSelectReturnValue<Item>;
 declare namespace useSelect {
-    export { stateChangeTypes };
+    var stateChangeTypes: typeof import("./stateChangeTypes");
 }
-import * as stateChangeTypes from "./stateChangeTypes";
+export default useSelect;