@react-aria/test-utils 1.0.0-nightly.5041 → 1.0.0-rc.0

package/dist/private/utils.js

@@ -0,0 +1,127 @@
+import {act as $1350703ef3ac1acc$export$3ba232387fd5d6dd} from "./act.js";
+import {fireEvent as $3ffHH$fireEvent} from "@testing-library/dom";
+
+/*
+ * Copyright 2023 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */ 
+
+const $b4e037a2907521c6$export$4bd1d2d5ba6f5eaf = 500;
+function $b4e037a2907521c6$var$testPlatform(re) {
+    return typeof window !== 'undefined' && window.navigator != null ? re.test(window.navigator['userAgentData']?.platform || window.navigator.platform) : false;
+}
+function $b4e037a2907521c6$var$cached(fn) {
+    if (process.env.NODE_ENV === 'test') return fn;
+    let res = null;
+    return ()=>{
+        if (res == null) res = fn();
+        return res;
+    };
+}
+const $b4e037a2907521c6$var$isMac = $b4e037a2907521c6$var$cached(function() {
+    return $b4e037a2907521c6$var$testPlatform(/^Mac/i);
+});
+function $b4e037a2907521c6$export$6fc0ccaebd758b9d() {
+    return $b4e037a2907521c6$var$isMac() ? 'Alt' : 'ControlLeft';
+}
+function $b4e037a2907521c6$export$7943c508934e27ce() {
+    return $b4e037a2907521c6$var$isMac() ? 'MetaLeft' : 'ControlLeft';
+}
+function $b4e037a2907521c6$export$bc3bc4a9206bf789(value) {
+    if (typeof HTMLElement !== 'undefined' && value instanceof HTMLElement) return value.cloneNode(false).outerHTML;
+    return String(value);
+}
+async function $b4e037a2907521c6$export$3a22a5a9bc0fd3b(opts) {
+    let { element: element, advanceTimer: advanceTimer, pointerOpts: pointerOpts = {} } = opts;
+    let pointerType = pointerOpts.pointerType ?? 'mouse';
+    let shouldFireCompatibilityEvents = false;
+    (0, $1350703ef3ac1acc$export$3ba232387fd5d6dd)(()=>{
+        shouldFireCompatibilityEvents = (0, $3ffHH$fireEvent).pointerDown(element, {
+            pointerType: pointerType,
+            ...pointerOpts
+        });
+    });
+    let shouldFocus = true;
+    if (shouldFireCompatibilityEvents) {
+        if (pointerType === 'touch') (0, $1350703ef3ac1acc$export$3ba232387fd5d6dd)(()=>{
+            shouldFocus = shouldFireCompatibilityEvents = (0, $3ffHH$fireEvent).touchStart(element, {
+                targetTouches: [
+                    {
+                        identifier: pointerOpts.pointerId,
+                        clientX: pointerOpts.clientX,
+                        clientY: pointerOpts.clientY
+                    }
+                ]
+            });
+        });
+        else if (pointerType === 'mouse') {
+            (0, $1350703ef3ac1acc$export$3ba232387fd5d6dd)(()=>{
+                shouldFocus = (0, $3ffHH$fireEvent).mouseDown(element, pointerOpts);
+            });
+            if (shouldFocus) (0, $1350703ef3ac1acc$export$3ba232387fd5d6dd)(()=>element.focus());
+        }
+    }
+    await (0, $1350703ef3ac1acc$export$3ba232387fd5d6dd)(async ()=>await advanceTimer($b4e037a2907521c6$export$4bd1d2d5ba6f5eaf));
+    (0, $1350703ef3ac1acc$export$3ba232387fd5d6dd)(()=>{
+        (0, $3ffHH$fireEvent).pointerUp(element, {
+            pointerType: pointerType,
+            ...pointerOpts
+        });
+    });
+    if (shouldFireCompatibilityEvents) {
+        if (pointerType === 'touch') {
+            (0, $1350703ef3ac1acc$export$3ba232387fd5d6dd)(()=>{
+                shouldFocus = (0, $3ffHH$fireEvent).touchEnd(element, {
+                    targetTouches: [
+                        {
+                            identifier: pointerOpts.pointerId,
+                            clientX: pointerOpts.clientX,
+                            clientY: pointerOpts.clientY
+                        }
+                    ]
+                });
+                shouldFocus = (0, $3ffHH$fireEvent).mouseDown(element, pointerOpts);
+            });
+            if (shouldFocus) (0, $1350703ef3ac1acc$export$3ba232387fd5d6dd)(()=>element.focus());
+            (0, $1350703ef3ac1acc$export$3ba232387fd5d6dd)(()=>{
+                (0, $3ffHH$fireEvent).mouseUp(element, pointerOpts);
+            });
+        } else if (pointerType === 'mouse') (0, $1350703ef3ac1acc$export$3ba232387fd5d6dd)(()=>{
+            (0, $3ffHH$fireEvent).mouseUp(element, pointerOpts);
+        });
+    }
+    (0, $1350703ef3ac1acc$export$3ba232387fd5d6dd)(()=>{
+        (0, $3ffHH$fireEvent).click(element, {
+            detail: 1,
+            ...pointerOpts
+        });
+    });
+}
+async function $b4e037a2907521c6$export$6ffa3eb717517feb(user, element, interactionType) {
+    if (interactionType === 'mouse') // Add coords with pressure so this isn't detected as a virtual click
+    await user.pointer({
+        target: element,
+        keys: '[MouseLeft]',
+        coords: {
+            pressure: 0.5
+        }
+    });
+    else if (interactionType === 'keyboard') {
+        (0, $1350703ef3ac1acc$export$3ba232387fd5d6dd)(()=>element.focus());
+        await user.keyboard('[Space]');
+    } else if (interactionType === 'touch') await user.pointer({
+        target: element,
+        keys: '[TouchA]'
+    });
+}
+
+
+export {$b4e037a2907521c6$export$4bd1d2d5ba6f5eaf as DEFAULT_LONG_PRESS_TIME, $b4e037a2907521c6$export$6fc0ccaebd758b9d as getAltKey, $b4e037a2907521c6$export$7943c508934e27ce as getMetaKey, $b4e037a2907521c6$export$bc3bc4a9206bf789 as formatTargetNode, $b4e037a2907521c6$export$3a22a5a9bc0fd3b as triggerLongPress, $b4e037a2907521c6$export$6ffa3eb717517feb as pressElement};
+//# sourceMappingURL=utils.js.map

package/dist/private/utils.js.map

@@ -0,0 +1 @@
+{"mappings":"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","sources":["packages/@react-aria/test-utils/src/utils.ts"],"sourcesContent":["/*\n * Copyright 2023 Adobe. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {act} from './act';\nimport {fireEvent} from '@testing-library/dom';\nimport {UserOpts} from './types';\n\nexport const DEFAULT_LONG_PRESS_TIME = 500;\nfunction testPlatform(re: RegExp) {\n  return typeof window !== 'undefined' && window.navigator != null\n    ? re.test(window.navigator['userAgentData']?.platform || window.navigator.platform)\n    : false;\n}\n\nfunction cached(fn: () => boolean) {\n  if (process.env.NODE_ENV === 'test') {\n    return fn;\n  }\n\n  let res: boolean | null = null;\n  return () => {\n    if (res == null) {\n      res = fn();\n    }\n    return res;\n  };\n}\n\nconst isMac = cached(function () {\n  return testPlatform(/^Mac/i);\n});\n\nexport function getAltKey(): 'Alt' | 'ControlLeft' {\n  return isMac() ? 'Alt' : 'ControlLeft';\n}\n\nexport function getMetaKey(): 'MetaLeft' | 'ControlLeft' {\n  return isMac() ? 'MetaLeft' : 'ControlLeft';\n}\n\nexport function formatTargetNode(value: number | string | HTMLElement): string {\n  if (typeof HTMLElement !== 'undefined' && value instanceof HTMLElement) {\n    return (value.cloneNode(false) as HTMLElement).outerHTML;\n  }\n  return String(value);\n}\n\n/**\n * Simulates a \"long press\" event on a element.\n *\n * @param opts - Options for the long press.\n * @param opts.element - Element to long press.\n * @param opts.advanceTimer - Function that when called advances the timers in your test suite by a\n *   specific amount of time(ms).\n * @param opts.pointeropts - Options to pass to the simulated event. Defaults to mouse. See\n *   https://testing-library.com/docs/dom-testing-library/api-events/#fireevent for more info.\n */\nexport async function triggerLongPress(opts: {\n  element: HTMLElement;\n  advanceTimer: (time: number) => unknown | Promise<unknown>;\n  pointerOpts?: Record<string, any>;\n}): Promise<void> {\n  let {element, advanceTimer, pointerOpts = {}} = opts;\n  let pointerType = pointerOpts.pointerType ?? 'mouse';\n  let shouldFireCompatibilityEvents = false;\n  act(() => {\n    shouldFireCompatibilityEvents = fireEvent.pointerDown(element, {pointerType, ...pointerOpts});\n  });\n  let shouldFocus = true;\n  if (shouldFireCompatibilityEvents) {\n    if (pointerType === 'touch') {\n      act(() => {\n        shouldFocus = shouldFireCompatibilityEvents = fireEvent.touchStart(element, {\n          targetTouches: [\n            {\n              identifier: pointerOpts.pointerId,\n              clientX: pointerOpts.clientX,\n              clientY: pointerOpts.clientY\n            }\n          ]\n        });\n      });\n    } else if (pointerType === 'mouse') {\n      act(() => {\n        shouldFocus = fireEvent.mouseDown(element, pointerOpts);\n      });\n      if (shouldFocus) {\n        act(() => element.focus());\n      }\n    }\n  }\n  await act(async () => await advanceTimer(DEFAULT_LONG_PRESS_TIME));\n  act(() => {\n    fireEvent.pointerUp(element, {pointerType, ...pointerOpts});\n  });\n  if (shouldFireCompatibilityEvents) {\n    if (pointerType === 'touch') {\n      act(() => {\n        shouldFocus = fireEvent.touchEnd(element, {\n          targetTouches: [\n            {\n              identifier: pointerOpts.pointerId,\n              clientX: pointerOpts.clientX,\n              clientY: pointerOpts.clientY\n            }\n          ]\n        });\n        shouldFocus = fireEvent.mouseDown(element, pointerOpts);\n      });\n      if (shouldFocus) {\n        act(() => element.focus());\n      }\n      act(() => {\n        fireEvent.mouseUp(element, pointerOpts);\n      });\n    } else if (pointerType === 'mouse') {\n      act(() => {\n        fireEvent.mouseUp(element, pointerOpts);\n      });\n    }\n  }\n  act(() => {\n    fireEvent.click(element, {detail: 1, ...pointerOpts});\n  });\n}\n\n// Docs cannot handle the types that userEvent actually declares, so hopefully this sub set is okay\nexport async function pressElement(\n  user: {\n    click: (element: Element) => Promise<void>;\n    keyboard: (keys: string) => Promise<void>;\n    pointer: (opts: {target: Element; keys: string; coords?: any}) => Promise<void>;\n  },\n  element: HTMLElement,\n  interactionType: UserOpts['interactionType']\n): Promise<void> {\n  if (interactionType === 'mouse') {\n    // Add coords with pressure so this isn't detected as a virtual click\n    await user.pointer({target: element, keys: '[MouseLeft]', coords: {pressure: 0.5}});\n  } else if (interactionType === 'keyboard') {\n    act(() => element.focus());\n    await user.keyboard('[Space]');\n  } else if (interactionType === 'touch') {\n    await user.pointer({target: element, keys: '[TouchA]'});\n  }\n}\n"],"names":[],"version":3,"file":"utils.js.map"}

package/dist/types/src/act.d.ts

@@ -0,0 +1,4 @@
+import * as ReactDOMTestUtils from 'react-dom/test-utils';
+declare let actImpl: typeof ReactDOMTestUtils.act;
+export declare const act: typeof actImpl;
+export {};

package/dist/types/src/checkboxgroup.d.ts

@@ -0,0 +1,47 @@
+import { CheckboxGroupTesterOpts, UserOpts } from './types';
+interface TriggerCheckboxOptions {
+    /**
+     * What interaction type to use when triggering a checkbox. Defaults to the interaction type set
+     * on the tester.
+     */
+    interactionType?: UserOpts['interactionType'];
+    /**
+     * The index, text, or node of the checkbox to toggle selection for.
+     */
+    checkbox: number | string | HTMLElement;
+}
+export declare class CheckboxGroupTester {
+    private user;
+    private _interactionType;
+    private _checkboxgroup;
+    constructor(opts: CheckboxGroupTesterOpts);
+    /**
+     * Set the interaction type used by the checkbox group tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Returns a checkbox matching the specified index or text content.
+     */
+    findCheckbox(opts: {
+        indexOrText: number | string;
+    }): HTMLElement;
+    private keyboardNavigateToCheckbox;
+    /**
+     * Toggles the specified checkbox. Defaults to using the interaction type set on the checkbox
+     * tester.
+     */
+    toggleCheckbox(opts: TriggerCheckboxOptions): Promise<void>;
+    /**
+     * Returns the checkboxgroup.
+     */
+    getCheckboxGroup(): HTMLElement;
+    /**
+     * Returns the checkboxes.
+     */
+    getCheckboxes(): HTMLElement[];
+    /**
+     * Returns the currently selected checkboxes in the checkboxgroup if any.
+     */
+    getSelectedCheckboxes(): HTMLElement[];
+}
+export {};

package/dist/types/src/combobox.d.ts

@@ -0,0 +1,87 @@
+import { ComboBoxTesterOpts, UserOpts } from './types';
+interface ComboBoxOpenOpts {
+    /**
+     * Whether the combobox opens on focus or needs to be manually opened via user action.
+     *
+     * @default 'manual'
+     */
+    triggerBehavior?: 'focus' | 'manual';
+    /**
+     * What interaction type to use when opening the combobox. Defaults to the interaction type set on
+     * the tester.
+     */
+    interactionType?: UserOpts['interactionType'];
+}
+interface ComboBoxSelectOpts extends ComboBoxOpenOpts {
+    /**
+     * The index, text, or node of the option to select. Option nodes can be sourced via
+     * `getOptions()`.
+     */
+    option: number | string | HTMLElement;
+    /**
+     * Whether or not the combobox closes on selection. Defaults to `true` for single select
+     * comboboxes and `false` for multi-select comboboxes.
+     */
+    closesOnSelect?: boolean;
+}
+export declare class ComboBoxTester {
+    private user;
+    private _interactionType;
+    private _combobox;
+    private _trigger;
+    constructor(opts: ComboBoxTesterOpts);
+    /**
+     * Set the interaction type used by the combobox tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Opens the combobox dropdown. Defaults to using the interaction type set on the combobox tester.
+     */
+    open(opts?: ComboBoxOpenOpts): Promise<void>;
+    /**
+     * Returns an option matching the specified index or text content.
+     */
+    findOption(opts: {
+        indexOrText: number | string;
+    }): HTMLElement;
+    private keyboardNavigateToOption;
+    /**
+     * Toggles the selection of the desired combobox option if possible. Defaults to using the
+     * interaction type set on the combobox tester. If necessary, will open the combobox dropdown
+     * beforehand. The desired option can be targeted via the option's node, the option's text, or the
+     * option's index.
+     */
+    toggleOptionSelection(opts: ComboBoxSelectOpts): Promise<void>;
+    /**
+     * Closes the combobox dropdown.
+     */
+    close(): Promise<void>;
+    /**
+     * Returns the combobox.
+     */
+    getCombobox(): HTMLElement;
+    /**
+     * Returns the combobox trigger button.
+     */
+    getTrigger(): HTMLElement;
+    /**
+     * Returns the combobox's listbox if present.
+     */
+    getListbox(): HTMLElement | null;
+    /**
+     * Returns the combobox's sections if present.
+     */
+    getSections(): HTMLElement[];
+    /**
+     * Returns the combobox's options if present. Can be filtered to a subsection of the listbox if
+     * provided via `element`.
+     */
+    getOptions(opts?: {
+        element?: HTMLElement;
+    }): HTMLElement[];
+    /**
+     * Returns the currently focused option in the combobox's dropdown if any.
+     */
+    getFocusedOption(): HTMLElement | null;
+}
+export {};

package/dist/types/src/dialog.d.ts

@@ -0,0 +1,37 @@
+import { DialogTesterOpts, UserOpts } from './types';
+interface DialogOpenOpts {
+    /**
+     * What interaction type to use when opening the dialog. Defaults to the interaction type set on
+     * the tester.
+     */
+    interactionType?: UserOpts['interactionType'];
+}
+export declare class DialogTester {
+    private user;
+    private _interactionType;
+    private _trigger;
+    private _dialog;
+    private _overlayType;
+    constructor(opts: DialogTesterOpts);
+    /**
+     * Set the interaction type used by the dialog tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Opens the dialog. Defaults to using the interaction type set on the dialog tester.
+     */
+    open(opts?: DialogOpenOpts): Promise<void>;
+    /**
+     * Closes the dialog via the Escape key.
+     */
+    close(): Promise<void>;
+    /**
+     * Returns the dialog's trigger.
+     */
+    getTrigger(): HTMLElement;
+    /**
+     * Returns the dialog if present.
+     */
+    getDialog(): HTMLElement | null;
+}
+export {};

package/dist/types/src/events.d.ts

@@ -0,0 +1,25 @@
+import { UserOpts } from './types';
+export declare const DEFAULT_LONG_PRESS_TIME = 500;
+export declare function getAltKey(): 'Alt' | 'ControlLeft';
+export declare function getMetaKey(): 'MetaLeft' | 'ControlLeft';
+/**
+ * Simulates a "long press" event on a element.
+ * @param opts - Options for the long press.
+ * @param opts.element - Element to long press.
+ * @param opts.advanceTimer - Function that when called advances the timers in your test suite by a specific amount of time(ms).
+ * @param opts.pointeropts - Options to pass to the simulated event. Defaults to mouse. See https://testing-library.com/docs/dom-testing-library/api-events/#fireevent for more info.
+ */
+export declare function triggerLongPress(opts: {
+    element: HTMLElement;
+    advanceTimer: (time: number) => unknown | Promise<unknown>;
+    pointerOpts?: Record<string, any>;
+}): Promise<void>;
+export declare function pressElement(user: {
+    click: (element: Element) => Promise<void>;
+    keyboard: (keys: string) => Promise<void>;
+    pointer: (opts: {
+        target: Element;
+        keys: string;
+        coords?: any;
+    }) => Promise<void>;
+}, element: HTMLElement, interactionType: UserOpts['interactionType']): Promise<void>;

package/dist/types/src/gridlist.d.ts

@@ -0,0 +1,56 @@
+import { GridListTesterOpts, GridRowActionOpts, ToggleGridRowOpts, UserOpts } from './types';
+interface GridListToggleRowOpts extends ToggleGridRowOpts {
+}
+interface GridListRowActionOpts extends GridRowActionOpts {
+}
+export declare class GridListTester {
+    private user;
+    private _interactionType;
+    private _advanceTimer;
+    private _direction;
+    private _gridlist;
+    private _layout;
+    constructor(opts: GridListTesterOpts);
+    /**
+     * Set the interaction type used by the gridlist tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Returns a row matching the specified index or text content.
+     */
+    findRow(opts: {
+        indexOrText: number | string;
+    }): HTMLElement;
+    private keyboardNavigateToRow;
+    /**
+     * Toggles the selection for the specified gridlist row. Defaults to using the interaction type
+     * set on the gridlist tester. Note that this will endevor to always add/remove JUST the provided
+     * row to the set of selected rows.
+     */
+    toggleRowSelection(opts: GridListToggleRowOpts): Promise<void>;
+    /**
+     * Triggers the action for the specified gridlist row. Defaults to using the interaction type set
+     * on the gridlist tester.
+     */
+    triggerRowAction(opts: GridListRowActionOpts): Promise<void>;
+    /**
+     * Returns the gridlist.
+     */
+    getGridlist(): HTMLElement;
+    /**
+     * Returns the gridlist's rows if any.
+     */
+    getRows(): HTMLElement[];
+    /**
+     * Returns the gridlist's selected rows if any.
+     */
+    getSelectedRows(): HTMLElement[];
+    /**
+     * Returns the gridlist's cells if any. Can be filtered against a specific row if provided via
+     * `element`.
+     */
+    getCells(opts?: {
+        element?: HTMLElement;
+    }): HTMLElement[];
+}
+export {};

package/dist/types/src/index.d.ts

@@ -0,0 +1,16 @@
+export { triggerLongPress } from './utils';
+export { installMouseEvent, installPointerEvent } from './testSetup';
+export { pointerMap } from './userEventMaps';
+export { User } from './user';
+export type { CheckboxGroupTester } from './checkboxgroup';
+export type { ComboBoxTester } from './combobox';
+export type { DialogTester } from './dialog';
+export type { GridListTester } from './gridlist';
+export type { ListBoxTester } from './listbox';
+export type { MenuTester } from './menu';
+export type { RadioGroupTester } from './radiogroup';
+export type { SelectTester } from './select';
+export type { TableTester } from './table';
+export type { TabsTester } from './tabs';
+export type { TreeTester } from './tree';
+export type { UserOpts } from './types';

package/dist/types/src/listbox.d.ts

@@ -0,0 +1,91 @@
+import { ListBoxTesterOpts, UserOpts } from './types';
+interface ListBoxToggleOptionOpts {
+    /**
+     * What interaction type to use when toggling selection for an option. Defaults to the interaction
+     * type set on the tester.
+     */
+    interactionType?: UserOpts['interactionType'];
+    /**
+     * The index, text, or node of the option to toggle selection for.
+     */
+    option: number | string | HTMLElement;
+    /**
+     * Whether the option should be triggered by Space or Enter in keyboard modality.
+     *
+     * @default 'Enter'
+     */
+    keyboardActivation?: 'Space' | 'Enter';
+    /**
+     * Whether the option needs to be long pressed to be selected. Depends on the listbox's
+     * implementation.
+     */
+    needsLongPress?: boolean;
+    /**
+     * Whether the listbox has a selectionBehavior of "toggle" or "replace" (aka highlight selection).
+     * This affects the user operations required to toggle option selection by adding modifier keys
+     * during user actions, useful when performing multi-option selection in a "selectionBehavior:
+     * 'replace'" listbox. If you would like to still simulate user actions (aka press) without these
+     * modifiers keys for a "selectionBehavior: replace" listbox, simply omit this option. See the
+     * [RAC Listbox docs](https://react-spectrum.adobe.com/react-aria/ListBox.html#selection-behavior)
+     * for more info on this behavior.
+     *
+     * @default 'toggle'
+     */
+    selectionBehavior?: 'toggle' | 'replace';
+}
+interface ListBoxOptionActionOpts extends Omit<ListBoxToggleOptionOpts, 'keyboardActivation' | 'needsLongPress'> {
+    /**
+     * Whether or not the option needs a double click to trigger the option action. Depends on the
+     * listbox's implementation.
+     */
+    needsDoubleClick?: boolean;
+}
+export declare class ListBoxTester {
+    private user;
+    private _interactionType;
+    private _advanceTimer;
+    private _listbox;
+    private _layout;
+    constructor(opts: ListBoxTesterOpts);
+    /**
+     * Set the interaction type used by the listbox tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Returns a option matching the specified index or text content.
+     */
+    findOption(opts: {
+        indexOrText: number | string;
+    }): HTMLElement;
+    private keyboardNavigateToOption;
+    /**
+     * Toggles the selection for the specified listbox option. Defaults to using the interaction type
+     * set on the listbox tester.
+     */
+    toggleOptionSelection(opts: ListBoxToggleOptionOpts): Promise<void>;
+    /**
+     * Triggers the action for the specified listbox option. Defaults to using the interaction type
+     * set on the listbox tester.
+     */
+    triggerOptionAction(opts: ListBoxOptionActionOpts): Promise<void>;
+    /**
+     * Returns the listbox.
+     */
+    getListbox(): HTMLElement;
+    /**
+     * Returns the listbox options. Can be filtered to a subsection of the listbox if provided via
+     * `element`.
+     */
+    getOptions(opts?: {
+        element?: HTMLElement;
+    }): HTMLElement[];
+    /**
+     * Returns the listbox's selected options if any.
+     */
+    getSelectedOptions(): HTMLElement[];
+    /**
+     * Returns the listbox's sections if any.
+     */
+    getSections(): HTMLElement[];
+}
+export {};

package/dist/types/src/menu.d.ts

@@ -0,0 +1,112 @@
+import { MenuTesterOpts, UserOpts } from './types';
+interface MenuOpenOpts {
+    /**
+     * Whether the menu needs to be long pressed to open.
+     */
+    needsLongPress?: boolean;
+    /**
+     * What interaction type to use when opening the menu. Defaults to the interaction type set on the
+     * tester.
+     */
+    interactionType?: UserOpts['interactionType'];
+    /**
+     * Whether to open the menu via ArrowUp or ArrowDown if in keyboard modality.
+     */
+    direction?: 'up' | 'down';
+}
+interface MenuSelectOpts extends MenuOpenOpts {
+    /**
+     * The index, text, or node of the option to select. Option nodes can be sourced via
+     * `getOptions()`.
+     */
+    option: number | string | HTMLElement;
+    /**
+     * The menu's selection mode. Will affect whether or not the menu is expected to be closed upon
+     * option selection.
+     *
+     * @default 'single'
+     */
+    menuSelectionMode?: 'single' | 'multiple';
+    /**
+     * Whether or not the menu closes on select. Depends on menu implementation and configuration.
+     *
+     * @default true
+     */
+    closesOnSelect?: boolean;
+    /**
+     * Whether the option should be triggered by Space or Enter in keyboard modality.
+     *
+     * @default 'Enter'
+     */
+    keyboardActivation?: 'Space' | 'Enter';
+}
+interface MenuOpenSubmenuOpts extends MenuOpenOpts {
+    /**
+     * The text or node of the submenu trigger to open. Available submenu trigger nodes can be sourced
+     * via `getSubmenuTriggers()`.
+     */
+    submenuTrigger: string | HTMLElement;
+}
+export declare class MenuTester {
+    private user;
+    private _interactionType;
+    private _advanceTimer;
+    private _trigger;
+    private _isSubmenu;
+    private _rootMenu;
+    constructor(opts: MenuTesterOpts);
+    /**
+     * Set the interaction type used by the menu tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Opens the menu. Defaults to using the interaction type set on the menu tester.
+     */
+    open(opts?: MenuOpenOpts): Promise<void>;
+    /**
+     * Returns a option matching the specified index or text content.
+     */
+    findOption(opts: {
+        indexOrText: number | string;
+    }): HTMLElement;
+    /**
+     * Toggles the selection of the desired menu option if possible. Defaults to using the interaction
+     * type set on the menu tester. If necessary, will open the menu dropdown beforehand. The desired
+     * option can be targeted via the option's node, the option's text, or the option's index.
+     */
+    toggleOptionSelection(opts: MenuSelectOpts): Promise<void>;
+    /**
+     * Opens the submenu. Defaults to using the interaction type set on the menu tester. The submenu
+     * trigger can be targeted via the trigger's node or the trigger's text.
+     */
+    openSubmenu(opts: MenuOpenSubmenuOpts): Promise<MenuTester>;
+    private keyboardNavigateToOption;
+    /**
+     * Closes the menu.
+     */
+    close(): Promise<void>;
+    /**
+     * Returns the menu's trigger.
+     */
+    getTrigger(): HTMLElement;
+    /**
+     * Returns the menu if present.
+     */
+    getMenu(): HTMLElement | null;
+    /**
+     * Returns the menu's sections if any.
+     */
+    getSections(): HTMLElement[];
+    /**
+     * Returns the menu's options if present. Can be filtered to a subsection of the menu if provided
+     * via `element`.
+     */
+    getOptions(opts?: {
+        element?: HTMLElement;
+    }): HTMLElement[];
+    /**
+     * Returns the menu's submenu triggers if any.
+     */
+    getSubmenuTriggers(): HTMLElement[];
+}
+export {};

package/dist/types/src/radiogroup.d.ts

@@ -0,0 +1,47 @@
+import { RadioGroupTesterOpts, UserOpts } from './types';
+interface TriggerRadioOptions {
+    /**
+     * What interaction type to use when triggering a radio. Defaults to the interaction type set on
+     * the tester.
+     */
+    interactionType?: UserOpts['interactionType'];
+    /**
+     * The index, text, or node of the radio to toggle selection for.
+     */
+    radio: number | string | HTMLElement;
+}
+export declare class RadioGroupTester {
+    private user;
+    private _interactionType;
+    private _radiogroup;
+    private _direction;
+    constructor(opts: RadioGroupTesterOpts);
+    /**
+     * Set the interaction type used by the radio tester.
+     */
+    setInteractionType(type: UserOpts['interactionType']): void;
+    /**
+     * Returns a radio matching the specified index or text content.
+     */
+    findRadio(opts: {
+        indexOrText: number | string;
+    }): HTMLElement;
+    private keyboardNavigateToRadio;
+    /**
+     * Triggers the specified radio. Defaults to using the interaction type set on the radio tester.
+     */
+    triggerRadio(opts: TriggerRadioOptions): Promise<void>;
+    /**
+     * Returns the radiogroup.
+     */
+    getRadioGroup(): HTMLElement;
+    /**
+     * Returns the radios.
+     */
+    getRadios(): HTMLElement[];
+    /**
+     * Returns the currently selected radio in the radiogroup if any.
+     */
+    getSelectedRadio(): HTMLElement | null;
+}
+export {};