@react-aria/test-utils 1.0.0-alpha.0 → 1.0.0-alpha.2

package/dist/user.module.js

@@ -0,0 +1,56 @@
+import {ComboBoxTester as $dab75f394483aa9c$export$f97e14e96d71ab3b} from "./combobox.module.js";
+import {GridListTester as $5ca9e9228f508f75$export$93a85aaed9fabd83} from "./gridlist.module.js";
+import {MenuTester as $74b93f0617179929$export$f73bbc9212ed861e} from "./menu.module.js";
+import {pointerMap as $50ecfb18069ec897$export$7dbde2c4caaa8d35} from "./userEventMaps.module.js";
+import {SelectTester as $4350df3e19e40e36$export$d1859707465446a9} from "./select.module.js";
+import {TableTester as $6d1e4cf220920c37$export$4c6a9d6ae3b0086} from "./table.module.js";
+import $gmkhN$testinglibraryuserevent from "@testing-library/user-event";
+
+/*
+ * Copyright 2024 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.
+ */ 
+
+
+
+
+
+
+let $0d71b4e9cc4df40a$var$keyToUtil = {
+    'Select': (0, $4350df3e19e40e36$export$d1859707465446a9),
+    'Table': (0, $6d1e4cf220920c37$export$4c6a9d6ae3b0086),
+    'Menu': (0, $74b93f0617179929$export$f73bbc9212ed861e),
+    'ComboBox': (0, $dab75f394483aa9c$export$f97e14e96d71ab3b),
+    'GridList': (0, $5ca9e9228f508f75$export$93a85aaed9fabd83)
+};
+let $0d71b4e9cc4df40a$var$defaultAdvanceTimer = async (waitTime)=>await new Promise((resolve)=>setTimeout(resolve, waitTime));
+class $0d71b4e9cc4df40a$export$1f44aaf2ec115b54 {
+    createTester(patternName, opts) {
+        return new $0d71b4e9cc4df40a$var$keyToUtil[patternName]({
+            ...opts,
+            user: this.user,
+            interactionType: this.interactionType,
+            advanceTimer: this.advanceTimer
+        });
+    }
+    constructor(opts = {}){
+        let { interactionType: interactionType, advanceTimer: advanceTimer } = opts;
+        this.user = (0, $gmkhN$testinglibraryuserevent).setup({
+            delay: null,
+            pointerMap: $50ecfb18069ec897$export$7dbde2c4caaa8d35
+        });
+        this.interactionType = interactionType;
+        this.advanceTimer = advanceTimer || $0d71b4e9cc4df40a$var$defaultAdvanceTimer;
+    }
+}
+
+
+export {$0d71b4e9cc4df40a$export$1f44aaf2ec115b54 as User};
+//# sourceMappingURL=user.module.js.map

package/dist/user.module.js.map

@@ -0,0 +1 @@
+{"mappings":";;;;;;;;AAAA;;;;;;;;;;CAUC;;;;;;;AAyBD,IAAI,kCAAY;IAAC,UAAU,CAAA,GAAA,yCAAW;IAAG,SAAS,CAAA,GAAA,wCAAU;IAAG,QAAQ,CAAA,GAAA,yCAAS;IAAG,YAAY,CAAA,GAAA,yCAAa;IAAG,YAAY,CAAA,GAAA,yCAAa;AAAC;AAoBzI,IAAI,4CAAsB,OAAO,WAAiC,MAAM,IAAI,QAAQ,CAAC,UAAY,WAAW,SAAS;AAE9G,MAAM;IAYX,aAAqC,WAAc,EAAE,IAA2B,EAAiB;QAC/F,OAAO,IAAI,AAAC,+BAAU,CAAC,YAAY,CAAC;YAAC,GAAG,IAAI;YAAE,MAAM,IAAI,CAAC,IAAI;YAAE,iBAAiB,IAAI,CAAC,eAAe;YAAE,cAAc,IAAI,CAAC,YAAY;QAAA;IACvI;IATA,YAAY,OAAiB,CAAC,CAAC,CAAE;QAC/B,IAAI,mBAAC,eAAe,gBAAE,YAAY,EAAC,GAAG;QACtC,IAAI,CAAC,IAAI,GAAG,CAAA,GAAA,8BAAQ,EAAE,KAAK,CAAC;YAAC,OAAO;wBAAM;QAAU;QACpD,IAAI,CAAC,eAAe,GAAG;QACvB,IAAI,CAAC,YAAY,GAAG,gBAAgB;IACtC;AAKF","sources":["packages/@react-aria/test-utils/src/user.ts"],"sourcesContent":["/*\n * Copyright 2024 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 {ComboBoxOptions, ComboBoxTester} from './combobox';\nimport {GridListOptions, GridListTester} from './gridlist';\nimport {MenuOptions, MenuTester} from './menu';\nimport {pointerMap} from './';\nimport {SelectOptions, SelectTester} from './select';\nimport {TableOptions, TableTester} from './table';\nimport userEvent from '@testing-library/user-event';\n\n// https://github.com/testing-library/dom-testing-library/issues/939#issuecomment-830771708 is an interesting way of allowing users to configure the timers\n// curent way is like https://testing-library.com/docs/user-event/options/#advancetimers,\nexport interface UserOpts {\n  interactionType?: 'mouse' | 'touch' | 'keyboard',\n  // If using fake timers user should provide something like (time) => jest.advanceTimersByTime(time))}\n  // A real timer user would pass async () => await new Promise((resolve) => setTimeout(resolve, waitTime))\n  // Time is in ms.\n  advanceTimer?: (time?: number) => void | Promise<unknown>\n}\n\nexport interface BaseTesterOpts {\n  // The base element for the given tester (e.g. the table, menu trigger, etc)\n  root: HTMLElement\n}\n\nlet keyToUtil = {'Select': SelectTester, 'Table': TableTester, 'Menu': MenuTester, 'ComboBox': ComboBoxTester, 'GridList': GridListTester} as const;\nexport type PatternNames = keyof typeof keyToUtil;\n\n// Conditional type: https://www.typescriptlang.org/docs/handbook/2/conditional-types.html\ntype ObjectType<T> =\n    T extends 'Select' ? SelectTester :\n    T extends 'Table' ? TableTester :\n    T extends 'Menu' ? MenuTester :\n    T extends 'ComboBox' ? ComboBoxTester :\n    T extends 'GridList' ? GridListTester :\n    never;\n\ntype ObjectOptionsTypes<T> =\n  T extends 'Select' ? SelectOptions :\n  T extends 'Table' ? TableOptions :\n  T extends 'Menu' ? MenuOptions :\n  T extends 'ComboBox' ? ComboBoxOptions :\n  T extends 'GridList' ? GridListOptions :\n  never;\n\nlet defaultAdvanceTimer = async (waitTime: number | undefined) => await new Promise((resolve) => setTimeout(resolve, waitTime));\n\nexport class User {\n  user;\n  interactionType: UserOpts['interactionType'];\n  advanceTimer: UserOpts['advanceTimer'];\n\n  constructor(opts: UserOpts = {}) {\n    let {interactionType, advanceTimer} = opts;\n    this.user = userEvent.setup({delay: null, pointerMap});\n    this.interactionType = interactionType;\n    this.advanceTimer = advanceTimer || defaultAdvanceTimer;\n  }\n\n  createTester<T extends PatternNames>(patternName: T, opts: ObjectOptionsTypes<T>): ObjectType<T> {\n    return new (keyToUtil)[patternName]({...opts, user: this.user, interactionType: this.interactionType, advanceTimer: this.advanceTimer}) as ObjectType<T>;\n  }\n}\n"],"names":[],"version":3,"file":"user.module.js.map"}

package/dist/userEventMaps.main.js

@@ -6,36 +6,36 @@ function $parcel$export(e, n, v, s) {
 $parcel$export(module.exports, "pointerMap", () => $0e568517a25183a7$export$7dbde2c4caaa8d35);
 let $0e568517a25183a7$export$7dbde2c4caaa8d35 = [
     {
-        name: "MouseLeft",
-        pointerType: "mouse",
-        button: "primary",
+        name: 'MouseLeft',
+        pointerType: 'mouse',
+        button: 'primary',
         height: 1,
         width: 1,
         pressure: 0.5
     },
     {
-        name: "MouseRight",
-        pointerType: "mouse",
-        button: "secondary"
+        name: 'MouseRight',
+        pointerType: 'mouse',
+        button: 'secondary'
     },
     {
-        name: "MouseMiddle",
-        pointerType: "mouse",
-        button: "auxiliary"
+        name: 'MouseMiddle',
+        pointerType: 'mouse',
+        button: 'auxiliary'
     },
     {
-        name: "TouchA",
-        pointerType: "touch",
+        name: 'TouchA',
+        pointerType: 'touch',
         height: 1,
         width: 1
     },
     {
-        name: "TouchB",
-        pointerType: "touch"
+        name: 'TouchB',
+        pointerType: 'touch'
     },
     {
-        name: "TouchC",
-        pointerType: "touch"
+        name: 'TouchC',
+        pointerType: 'touch'
     }
 ];
 

package/dist/userEventMaps.mjs

@@ -1,38 +1,38 @@
 let $50ecfb18069ec897$export$7dbde2c4caaa8d35 = [
     {
-        name: "MouseLeft",
-        pointerType: "mouse",
-        button: "primary",
+        name: 'MouseLeft',
+        pointerType: 'mouse',
+        button: 'primary',
         height: 1,
         width: 1,
         pressure: 0.5
     },
     {
-        name: "MouseRight",
-        pointerType: "mouse",
-        button: "secondary"
+        name: 'MouseRight',
+        pointerType: 'mouse',
+        button: 'secondary'
     },
     {
-        name: "MouseMiddle",
-        pointerType: "mouse",
-        button: "auxiliary"
+        name: 'MouseMiddle',
+        pointerType: 'mouse',
+        button: 'auxiliary'
     },
     {
-        name: "TouchA",
-        pointerType: "touch",
+        name: 'TouchA',
+        pointerType: 'touch',
         height: 1,
         width: 1
     },
     {
-        name: "TouchB",
-        pointerType: "touch"
+        name: 'TouchB',
+        pointerType: 'touch'
     },
     {
-        name: "TouchC",
-        pointerType: "touch"
+        name: 'TouchC',
+        pointerType: 'touch'
     }
 ];
 
 
 export {$50ecfb18069ec897$export$7dbde2c4caaa8d35 as pointerMap};
-//# sourceMappingURL=userEventMaps.mjs.map
+//# sourceMappingURL=userEventMaps.module.js.map

package/dist/userEventMaps.module.js

@@ -1,35 +1,35 @@
 let $50ecfb18069ec897$export$7dbde2c4caaa8d35 = [
     {
-        name: "MouseLeft",
-        pointerType: "mouse",
-        button: "primary",
+        name: 'MouseLeft',
+        pointerType: 'mouse',
+        button: 'primary',
         height: 1,
         width: 1,
         pressure: 0.5
     },
     {
-        name: "MouseRight",
-        pointerType: "mouse",
-        button: "secondary"
+        name: 'MouseRight',
+        pointerType: 'mouse',
+        button: 'secondary'
     },
     {
-        name: "MouseMiddle",
-        pointerType: "mouse",
-        button: "auxiliary"
+        name: 'MouseMiddle',
+        pointerType: 'mouse',
+        button: 'auxiliary'
     },
     {
-        name: "TouchA",
-        pointerType: "touch",
+        name: 'TouchA',
+        pointerType: 'touch',
         height: 1,
         width: 1
     },
     {
-        name: "TouchB",
-        pointerType: "touch"
+        name: 'TouchB',
+        pointerType: 'touch'
     },
     {
-        name: "TouchC",
-        pointerType: "touch"
+        name: 'TouchC',
+        pointerType: 'touch'
     }
 ];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-aria/test-utils",
-  "version": "1.0.0-alpha.0",
+  "version": "1.0.0-alpha.2",
   "description": "Testing utils for react-aria patterns",
   "license": "Apache-2.0",
   "main": "dist/main.js",
@@ -25,13 +25,12 @@
     "@swc/helpers": "^0.5.0"
   },
   "peerDependencies": {
-    "@testing-library/react": "^13.0.0 || ^14.0.0",
+    "@testing-library/react": "^15.0.7",
     "@testing-library/user-event": "^13.0.0 || ^14.0.0",
-    "jest": "^27.0.0",
-    "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0"
+    "jest": "^29.5.0",
+    "react": "^16.8.0 || ^17.0.0-rc.1 || ^18.0.0 || ^19.0.0"
   },
   "publishConfig": {
     "access": "public"
-  },
-  "gitHead": "f645f29edc1322153fd60af4640cbcab1d992dbd"
-}
+  }
+}

package/src/combobox.ts

@@ -0,0 +1,188 @@
+/*
+ * Copyright 2024 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.
+ */
+
+import {act, waitFor, within} from '@testing-library/react';
+import {BaseTesterOpts, UserOpts} from './user';
+
+export interface ComboBoxOptions extends UserOpts, BaseTesterOpts {
+  user: any,
+  trigger?: HTMLElement
+}
+
+export class ComboBoxTester {
+  private user;
+  private _interactionType: UserOpts['interactionType'];
+  private _combobox: HTMLElement;
+  private _trigger: HTMLElement | undefined;
+
+  constructor(opts: ComboBoxOptions) {
+    let {root, trigger, user, interactionType} = opts;
+    this.user = user;
+    this._interactionType = interactionType || 'mouse';
+
+    // Handle case where element provided is a wrapper around the combobox. The expectation is that the user at least uses a ref/data attribute to
+    // query their combobox/combobox wrapper (in the case of RSP) which they then pass to thhis
+    this._combobox = root;
+    let combobox = within(root).queryByRole('combobox');
+    if (combobox) {
+      this._combobox = combobox;
+    }
+
+    // This is for if user need to directly set the trigger button element (aka the element provided in setElement was the combobox input or the trigger is somewhere unexpected)
+    if (trigger) {
+      this._trigger = trigger;
+    } else {
+      let trigger = within(root).queryByRole('button', {hidden: true});
+      if (trigger) {
+        this._trigger = trigger;
+      } else {
+        // For cases like https://www.w3.org/WAI/ARIA/apg/patterns/combobox/examples/combobox-select-only/ where the combobox
+        // is also the trigger button
+        this._trigger = this._combobox;
+      }
+    }
+  }
+
+  setInteractionType = (type: UserOpts['interactionType']) => {
+    this._interactionType = type;
+  };
+
+  open = async (opts: {triggerBehavior?: 'focus' | 'manual', interactionType?: UserOpts['interactionType']} = {}) => {
+    let {triggerBehavior = 'manual', interactionType = this._interactionType} = opts;
+    let trigger = this.trigger;
+    let combobox = this.combobox;
+    let isDisabled = trigger!.hasAttribute('disabled');
+
+    if (interactionType === 'mouse') {
+      if (triggerBehavior === 'focus') {
+        await this.user.click(combobox);
+      } else {
+        await this.user.click(trigger);
+      }
+    } else if (interactionType === 'keyboard' && this._trigger != null) {
+      act(() => this._trigger!.focus());
+      if (triggerBehavior !== 'focus') {
+        await this.user.keyboard('{ArrowDown}');
+      }
+    } else if (interactionType === 'touch') {
+      if (triggerBehavior === 'focus') {
+        await this.user.pointer({target: combobox, keys: '[TouchA]'});
+      } else {
+        await this.user.pointer({target: trigger, keys: '[TouchA]'});
+      }
+    }
+
+    await waitFor(() => {
+      if (!isDisabled && combobox.getAttribute('aria-controls') == null) {
+        throw new Error('No aria-controls found on combobox trigger element.');
+      } else {
+        return true;
+      }
+    });
+    let listBoxId = combobox.getAttribute('aria-controls');
+    await waitFor(() => {
+      if (!isDisabled && (!listBoxId || document.getElementById(listBoxId) == null)) {
+        throw new Error(`Listbox with id of ${listBoxId} not found in document.`);
+      } else {
+        return true;
+      }
+    });
+  };
+
+  selectOption = async (opts: {option?: HTMLElement, optionText?: string, triggerBehavior?: 'focus' | 'manual', interactionType?: UserOpts['interactionType']} = {}) => {
+    let {optionText, option, triggerBehavior, interactionType = this._interactionType} = opts;
+    if (!this.combobox.getAttribute('aria-controls')) {
+      await this.open({triggerBehavior});
+    }
+
+    let listbox = this.listbox;
+    if (listbox) {
+      if (!option && optionText) {
+        option = within(listbox).getByText(optionText);
+      }
+
+      // TODO: keyboard method of selecting the the option is a bit tricky unless I simply simulate the user pressing the down arrow
+      // the required amount of times to reach the option. For now just click the option even in keyboard mode
+      if (interactionType === 'mouse' || interactionType === 'keyboard') {
+        await this.user.click(option);
+      } else {
+        await this.user.pointer({target: option, keys: '[TouchA]'});
+      }
+
+      if (option && option.getAttribute('href') == null) {
+        await waitFor(() => {
+          if (document.contains(listbox)) {
+            throw new Error('Expected listbox element to not be in the document after selecting an option');
+          } else {
+            return true;
+          }
+        });
+      }
+    } else {
+      throw new Error("Attempted to select a option in the combobox, but the listbox wasn't found.");
+    }
+  };
+
+  close = async () => {
+    let listbox = this.listbox;
+    if (listbox) {
+      act(() => this.combobox.focus());
+      await this.user.keyboard('[Escape]');
+
+      await waitFor(() => {
+        if (document.contains(listbox)) {
+          throw new Error('Expected listbox element to not be in the document after selecting an option');
+        } else {
+          return true;
+        }
+      });
+    }
+  };
+
+  get combobox() {
+    return this._combobox;
+  }
+
+  get trigger() {
+    return this._trigger;
+  }
+
+  get listbox() {
+    let listBoxId = this.combobox.getAttribute('aria-controls');
+    return listBoxId ? document.getElementById(listBoxId) || undefined : undefined;
+  }
+
+  options = (opts: {element?: HTMLElement} = {}): HTMLElement[] | never[] => {
+    let {element} = opts;
+    element = element || this.listbox;
+    let options = [];
+    if (element) {
+      options = within(element).queryAllByRole('option');
+    }
+
+    return options;
+  };
+
+  get sections() {
+    let listbox = this.listbox;
+    if (listbox) {
+      return within(listbox).queryAllByRole('group');
+    } else {
+      return [];
+    }
+  }
+
+  get focusedOption() {
+    let focusedOptionId = this.combobox.getAttribute('aria-activedescendant');
+    return focusedOptionId ? document.getElementById(focusedOptionId) : undefined;
+  }
+}

package/src/events.ts

@@ -11,18 +11,38 @@
  */
 
 import {act, fireEvent} from '@testing-library/react';
+import {UserOpts} from './user';
 
 export const DEFAULT_LONG_PRESS_TIME = 500;
 
 /**
  * Simulates a "long press" event on a element.
- * @param element - Element to long press.
- * @param opts - Options to pass to the simulated event. See https://testing-library.com/docs/dom-testing-library/api-events/#fireevent for more info.
+ * @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 function triggerLongPress(element: HTMLElement, opts = {}): void {
-  fireEvent.pointerDown(element, {pointerType: 'touch', ...opts});
-  act(() => {
-    jest.advanceTimersByTime(DEFAULT_LONG_PRESS_TIME);
-  });
-  fireEvent.pointerUp(element, {pointerType: 'touch', ...opts});
+export async function triggerLongPress(opts: {element: HTMLElement, advanceTimer: (time?: number) => void | Promise<unknown>, pointerOpts?: {}}) {
+  // TODO: note that this only works if the code from installPointerEvent is called somewhere in the test BEFORE the
+  // render. Perhaps we should rely on the user setting that up since I'm not sure there is a great way to set that up here in the
+  // util before first render. Will need to document it well
+  let {element, advanceTimer, pointerOpts = {}} = opts;
+  await fireEvent.pointerDown(element, {pointerType: 'mouse', ...pointerOpts});
+  await act(async () => await advanceTimer(DEFAULT_LONG_PRESS_TIME));
+  await fireEvent.pointerUp(element, {pointerType: 'mouse', ...pointerOpts});
+}
+
+
+export async function pressElement(user, element: HTMLElement, interactionType: UserOpts['interactionType']) {
+  if (interactionType === 'mouse') {
+    await user.click(element);
+  } else if (interactionType === 'keyboard') {
+    // TODO: For the keyboard flow, I wonder if it would be reasonable to just do fireEvent directly on the obtained row node or if we should
+    // stick to simulting an actual user's keyboard operations as closely as possible
+    // There are problems when using this approach though, actions like trying to trigger the select all checkbox and stuff behave oddly.
+    act(() => element.focus());
+    await user.keyboard('[Space]');
+  } else if (interactionType === 'touch') {
+    await user.pointer({target: element, keys: '[TouchA]'});
+  }
 }

package/src/gridlist.ts

@@ -0,0 +1,116 @@
+/*
+ * Copyright 2024 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.
+ */
+
+import {act, within} from '@testing-library/react';
+import {BaseTesterOpts, UserOpts} from './user';
+import {pressElement} from './events';
+
+export interface GridListOptions extends UserOpts, BaseTesterOpts {
+  user: any
+}
+export class GridListTester {
+  private user;
+  private _interactionType: UserOpts['interactionType'];
+  private _gridlist: HTMLElement;
+
+
+  constructor(opts: GridListOptions) {
+    let {root, user, interactionType} = opts;
+    this.user = user;
+    this._interactionType = interactionType || 'mouse';
+    this._gridlist = root;
+  }
+
+  setInteractionType = (type: UserOpts['interactionType']) => {
+    this._interactionType = type;
+  };
+
+  // TODO: support long press? This is also pretty much the same as table's toggleRowSelection so maybe can share
+  // For now, don't include long press, see if people need it or if we should just expose long press as a separate util if it isn't very common
+  // If the current way of passing in the user specified advance timers is ok, then I'd be find including long press
+  // Maybe also support an option to force the click to happen on a specific part of the element (checkbox or row). That way
+  // the user can test a specific type of interaction?
+  toggleRowSelection = async (opts: {index?: number, text?: string, interactionType?: UserOpts['interactionType']} = {}) => {
+    let {index, text, interactionType = this._interactionType} = opts;
+
+    let row = this.findRow({index, text});
+    let rowCheckbox = within(row).queryByRole('checkbox');
+    if (rowCheckbox) {
+      await pressElement(this.user, rowCheckbox, interactionType);
+    } else {
+      let cell = within(row).getAllByRole('gridcell')[0];
+      await pressElement(this.user, cell, interactionType);
+    }
+  };
+
+  // TODO: pretty much the same as table except it uses this.gridlist. Make common between the two by accepting an option for
+  // an element?
+  findRow = (opts: {index?: number, text?: string}) => {
+    let {
+      index,
+      text
+    } = opts;
+
+    let row;
+    if (index != null) {
+      row = this.rows[index];
+    } else if (text != null) {
+      row = within(this?.gridlist).getByText(text);
+      while (row && row.getAttribute('role') !== 'row') {
+        row = row.parentElement;
+      }
+    }
+
+    return row;
+  };
+
+  // TODO: There is a more difficult use case where the row has/behaves as link, don't think we have a good way to determine that unless the
+  // user specificlly tells us
+  triggerRowAction = async (opts: {index?: number, text?: string, needsDoubleClick?: boolean, interactionType?: UserOpts['interactionType']}) => {
+    let {
+      index,
+      text,
+      needsDoubleClick,
+      interactionType = this._interactionType
+    } = opts;
+
+    let row = this.findRow({index, text});
+    if (row) {
+      if (needsDoubleClick) {
+        await this.user.dblClick(row);
+      } else if (interactionType === 'keyboard') {
+        act(() => row.focus());
+        await this.user.keyboard('[Enter]');
+      } else {
+        await pressElement(this.user, row, interactionType);
+      }
+    }
+  };
+
+  // TODO: do we really need this getter? Theoretically the user already has the reference to the gridlist
+  get gridlist() {
+    return this._gridlist;
+  }
+
+  get rows() {
+    return within(this?.gridlist).queryAllByRole('row');
+  }
+
+  get selectedRows() {
+    return this.rows.filter(row => row.getAttribute('aria-selected') === 'true');
+  }
+
+  cells = (opts: {element?: HTMLElement} = {}) => {
+    let {element} = opts;
+    return within(element || this.gridlist).queryAllByRole('gridcell');
+  };
+}

package/src/index.ts

@@ -10,6 +10,9 @@
  * governing permissions and limitations under the License.
  */
 
-export * from './events';
-export * from './testSetup';
-export * from './userEventMaps';
+export {triggerLongPress} from './events';
+export {installMouseEvent, installPointerEvent} from './testSetup';
+export {pointerMap} from './userEventMaps';
+export {User} from './user';
+
+export type {UserOpts} from './user';