@gtkx/testing 0.1.49 → 0.1.51

package/README.md

@@ -159,7 +159,9 @@ Query types: `ByRole`, `ByText`, `ByLabelText`, `ByTestId`
 - `userEvent.activate(element)` - Activate element (e.g., press Enter in input)
 - `userEvent.type(element, text)` - Type text into input
 - `userEvent.clear(element)` - Clear input text
-- `userEvent.setup()` - Create reusable instance
+- `userEvent.tab(element, options?)` - Simulate Tab navigation
+- `userEvent.selectOptions(element, values)` - Select options in ComboBox/ListBox
+- `userEvent.deselectOptions(element, values)` - Deselect options in ListBox
 
 **Low-level Events**:
 - `fireEvent(element, signalName, ...args)` - Emit any GTK signal with optional arguments
@@ -170,14 +172,6 @@ Query types: `ByRole`, `ByText`, `ByLabelText`, `ByTestId`
 
 ## Examples
 
-### Counter
-
-A minimal counter app demonstrating state management:
-
-```bash
-turbo start --filter=counter-example
-```
-
 ### GTK4 Demo
 
 A comprehensive showcase of GTK4 widgets and features:
@@ -186,12 +180,13 @@ A comprehensive showcase of GTK4 widgets and features:
 turbo start --filter=gtk4-demo
 ```
 
-### List Example
+### Todo App
 
-Comprehensive showcase of ListView, GridView, and ColumnView with sorting:
+A todo app demonstrating `@gtkx/testing` with realistic component tests:
 
 ```bash
-turbo start --filter=list-example
+turbo start --filter=todo
+turbo test --filter=todo
 ```
 
 ## Packages

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export { findAllByLabelText, findAllByRole, findAllByTestId, findAllByText, find
 export { cleanup, render, teardown } from "./render.js";
 export { screen } from "./screen.js";
 export type { BoundQueries, ByRoleOptions, RenderOptions, RenderResult, TextMatchOptions, WaitForOptions, } from "./types.js";
-export type { UserEventInstance, UserEventOptions } from "./user-event.js";
+export type { TabOptions } from "./user-event.js";
 export { userEvent } from "./user-event.js";
 export { waitFor, waitForElementToBeRemoved } from "./wait-for.js";
 export { within } from "./within.js";

package/dist/queries.d.ts

@@ -22,7 +22,7 @@ export declare const findAllByRole: (container: Container, role: AccessibleRole,
  * Waits for and finds a single widget matching the specified label text.
  * @param container - The container to search within
  * @param text - The text or pattern to match
- * @param options - Text matching options (exact, normalizer)
+ * @param options - Text matching options (exact, normalizer, timeout)
  * @returns Promise resolving to the matching widget
  */
 export declare const findByLabelText: (container: Container, text: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget>;
@@ -30,7 +30,7 @@ export declare const findByLabelText: (container: Container, text: string | RegE
  * Waits for and finds all widgets matching the specified label text.
  * @param container - The container to search within
  * @param text - The text or pattern to match
- * @param options - Text matching options (exact, normalizer)
+ * @param options - Text matching options (exact, normalizer, timeout)
  * @returns Promise resolving to array of matching widgets
  */
 export declare const findAllByLabelText: (container: Container, text: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget[]>;
@@ -38,7 +38,7 @@ export declare const findAllByLabelText: (container: Container, text: string | R
  * Waits for and finds a single widget matching the specified text content.
  * @param container - The container to search within
  * @param text - The text or pattern to match
- * @param options - Text matching options (exact, normalizer)
+ * @param options - Text matching options (exact, normalizer, timeout)
  * @returns Promise resolving to the matching widget
  */
 export declare const findByText: (container: Container, text: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget>;
@@ -46,7 +46,7 @@ export declare const findByText: (container: Container, text: string | RegExp, o
  * Waits for and finds all widgets matching the specified text content.
  * @param container - The container to search within
  * @param text - The text or pattern to match
- * @param options - Text matching options (exact, normalizer)
+ * @param options - Text matching options (exact, normalizer, timeout)
  * @returns Promise resolving to array of matching widgets
  */
 export declare const findAllByText: (container: Container, text: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget[]>;
@@ -54,7 +54,7 @@ export declare const findAllByText: (container: Container, text: string | RegExp
  * Waits for and finds a single widget matching the specified test ID.
  * @param container - The container to search within
  * @param testId - The test ID or pattern to match
- * @param options - Text matching options (exact, normalizer)
+ * @param options - Text matching options (exact, normalizer, timeout)
  * @returns Promise resolving to the matching widget
  */
 export declare const findByTestId: (container: Container, testId: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget>;
@@ -62,7 +62,7 @@ export declare const findByTestId: (container: Container, testId: string | RegEx
  * Waits for and finds all widgets matching the specified test ID.
  * @param container - The container to search within
  * @param testId - The test ID or pattern to match
- * @param options - Text matching options (exact, normalizer)
+ * @param options - Text matching options (exact, normalizer, timeout)
  * @returns Promise resolving to array of matching widgets
  */
 export declare const findAllByTestId: (container: Container, testId: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget[]>;

package/dist/queries.js

@@ -1,7 +1,8 @@
 import { getObject } from "@gtkx/ffi";
-import { AccessibleRole, Button, CheckButton, Expander, Label, ToggleButton } from "@gtkx/ffi/gtk";
+import { AccessibleRole, Button, CheckButton, Editable, Expander, Frame, Label, StackPage, Switch, ToggleButton, Window, } from "@gtkx/ffi/gtk";
 import { findAll } from "./traversal.js";
 import { waitFor } from "./wait-for.js";
+import { asAccessible } from "./widget.js";
 const DEFAULT_NORMALIZER = (text) => text.trim().replace(/\s+/g, " ");
 const normalizeText = (text, options) => {
     const normalizer = options?.normalizer ?? DEFAULT_NORMALIZER;
@@ -18,12 +19,25 @@ const matchText = (actual, expected, options) => {
     }
     return expected.test(normalizedActual);
 };
-const asAccessible = (widget) => widget;
 const asButton = (widget) => getObject(widget.ptr, Button);
 const asLabel = (widget) => getObject(widget.ptr, Label);
 const asCheckButton = (widget) => getObject(widget.ptr, CheckButton);
 const asToggleButton = (widget) => getObject(widget.ptr, ToggleButton);
 const asExpander = (widget) => getObject(widget.ptr, Expander);
+const asFrame = (widget) => getObject(widget.ptr, Frame);
+const asWindow = (widget) => getObject(widget.ptr, Window);
+const asStackPage = (widget) => getObject(widget.ptr, StackPage);
+const ROLES_WITH_INTERNAL_LABELS = new Set([
+    AccessibleRole.BUTTON,
+    AccessibleRole.TOGGLE_BUTTON,
+    AccessibleRole.CHECKBOX,
+    AccessibleRole.RADIO,
+    AccessibleRole.MENU_ITEM,
+    AccessibleRole.MENU_ITEM_CHECKBOX,
+    AccessibleRole.MENU_ITEM_RADIO,
+    AccessibleRole.TAB,
+    AccessibleRole.LINK,
+]);
 const isInternalLabel = (widget) => {
     const accessible = asAccessible(widget);
     if (accessible.getAccessibleRole() !== AccessibleRole.LABEL)
@@ -32,13 +46,7 @@ const isInternalLabel = (widget) => {
     if (!parent)
         return false;
     const parentRole = asAccessible(parent).getAccessibleRole();
-    return (parentRole === AccessibleRole.BUTTON ||
-        parentRole === AccessibleRole.TOGGLE_BUTTON ||
-        parentRole === AccessibleRole.CHECKBOX ||
-        parentRole === AccessibleRole.RADIO ||
-        parentRole === AccessibleRole.MENU_ITEM ||
-        parentRole === AccessibleRole.MENU_ITEM_CHECKBOX ||
-        parentRole === AccessibleRole.MENU_ITEM_RADIO);
+    return ROLES_WITH_INTERNAL_LABELS.has(parentRole);
 };
 const getWidgetText = (widget) => {
     if (isInternalLabel(widget))
@@ -46,19 +54,40 @@ const getWidgetText = (widget) => {
     const role = asAccessible(widget).getAccessibleRole();
     switch (role) {
         case AccessibleRole.BUTTON:
+        case AccessibleRole.LINK:
+        case AccessibleRole.TAB:
+            return asButton(widget).getLabel();
         case AccessibleRole.TOGGLE_BUTTON:
+            return asToggleButton(widget).getLabel();
         case AccessibleRole.CHECKBOX:
         case AccessibleRole.RADIO:
-        case AccessibleRole.MENU_ITEM:
-        case AccessibleRole.MENU_ITEM_CHECKBOX:
-        case AccessibleRole.MENU_ITEM_RADIO:
-            return asButton(widget).getLabel();
+            return asCheckButton(widget).getLabel();
         case AccessibleRole.LABEL:
             return asLabel(widget).getLabel();
         case AccessibleRole.TEXT_BOX:
         case AccessibleRole.SEARCH_BOX:
         case AccessibleRole.SPIN_BUTTON:
-            return widget.getText();
+            return getObject(widget.ptr, Editable).getText();
+        case AccessibleRole.GROUP:
+            try {
+                return asFrame(widget).getLabel();
+            }
+            catch {
+                return null;
+            }
+        case AccessibleRole.WINDOW:
+        case AccessibleRole.DIALOG:
+        case AccessibleRole.ALERT_DIALOG:
+            return asWindow(widget).getTitle();
+        case AccessibleRole.TAB_PANEL:
+            try {
+                return asStackPage(widget).getTitle();
+            }
+            catch {
+                return null;
+            }
+        case AccessibleRole.SWITCH:
+            return null;
         default:
             return null;
     }
@@ -66,15 +95,20 @@ const getWidgetText = (widget) => {
 const getWidgetTestId = (widget) => {
     return widget.getName();
 };
+const asSwitch = (widget) => getObject(widget.ptr, Switch);
 const getWidgetCheckedState = (widget) => {
     const role = asAccessible(widget).getAccessibleRole();
-    if (role === AccessibleRole.CHECKBOX || role === AccessibleRole.RADIO) {
-        return asCheckButton(widget).getActive();
-    }
-    if (role === AccessibleRole.TOGGLE_BUTTON) {
-        return asToggleButton(widget).getActive();
+    switch (role) {
+        case AccessibleRole.CHECKBOX:
+        case AccessibleRole.RADIO:
+            return asCheckButton(widget).getActive();
+        case AccessibleRole.TOGGLE_BUTTON:
+            return asToggleButton(widget).getActive();
+        case AccessibleRole.SWITCH:
+            return asSwitch(widget).getActive();
+        default:
+            return undefined;
     }
-    return undefined;
 };
 const getWidgetExpandedState = (widget) => {
     const role = asAccessible(widget).getAccessibleRole();
@@ -211,7 +245,7 @@ const getByTestId = (container, testId, options) => {
  * @param options - Additional filtering options (name, checked, expanded)
  * @returns Promise resolving to the matching widget
  */
-export const findByRole = async (container, role, options) => waitFor(() => getByRole(container, role, options));
+export const findByRole = async (container, role, options) => waitFor(() => getByRole(container, role, options), { timeout: options?.timeout });
 /**
  * Waits for and finds all widgets matching the specified accessible role.
  * @param container - The container to search within
@@ -219,52 +253,52 @@ export const findByRole = async (container, role, options) => waitFor(() => getB
  * @param options - Additional filtering options (name, checked, expanded)
  * @returns Promise resolving to array of matching widgets
  */
-export const findAllByRole = async (container, role, options) => waitFor(() => getAllByRole(container, role, options));
+export const findAllByRole = async (container, role, options) => waitFor(() => getAllByRole(container, role, options), { timeout: options?.timeout });
 /**
  * Waits for and finds a single widget matching the specified label text.
  * @param container - The container to search within
  * @param text - The text or pattern to match
- * @param options - Text matching options (exact, normalizer)
+ * @param options - Text matching options (exact, normalizer, timeout)
  * @returns Promise resolving to the matching widget
  */
-export const findByLabelText = async (container, text, options) => waitFor(() => getByLabelText(container, text, options));
+export const findByLabelText = async (container, text, options) => waitFor(() => getByLabelText(container, text, options), { timeout: options?.timeout });
 /**
  * Waits for and finds all widgets matching the specified label text.
  * @param container - The container to search within
  * @param text - The text or pattern to match
- * @param options - Text matching options (exact, normalizer)
+ * @param options - Text matching options (exact, normalizer, timeout)
  * @returns Promise resolving to array of matching widgets
  */
-export const findAllByLabelText = async (container, text, options) => waitFor(() => getAllByLabelText(container, text, options));
+export const findAllByLabelText = async (container, text, options) => waitFor(() => getAllByLabelText(container, text, options), { timeout: options?.timeout });
 /**
  * Waits for and finds a single widget matching the specified text content.
  * @param container - The container to search within
  * @param text - The text or pattern to match
- * @param options - Text matching options (exact, normalizer)
+ * @param options - Text matching options (exact, normalizer, timeout)
  * @returns Promise resolving to the matching widget
  */
-export const findByText = async (container, text, options) => waitFor(() => getByText(container, text, options));
+export const findByText = async (container, text, options) => waitFor(() => getByText(container, text, options), { timeout: options?.timeout });
 /**
  * Waits for and finds all widgets matching the specified text content.
  * @param container - The container to search within
  * @param text - The text or pattern to match
- * @param options - Text matching options (exact, normalizer)
+ * @param options - Text matching options (exact, normalizer, timeout)
  * @returns Promise resolving to array of matching widgets
  */
-export const findAllByText = async (container, text, options) => waitFor(() => getAllByText(container, text, options));
+export const findAllByText = async (container, text, options) => waitFor(() => getAllByText(container, text, options), { timeout: options?.timeout });
 /**
  * Waits for and finds a single widget matching the specified test ID.
  * @param container - The container to search within
  * @param testId - The test ID or pattern to match
- * @param options - Text matching options (exact, normalizer)
+ * @param options - Text matching options (exact, normalizer, timeout)
  * @returns Promise resolving to the matching widget
  */
-export const findByTestId = async (container, testId, options) => waitFor(() => getByTestId(container, testId, options));
+export const findByTestId = async (container, testId, options) => waitFor(() => getByTestId(container, testId, options), { timeout: options?.timeout });
 /**
  * Waits for and finds all widgets matching the specified test ID.
  * @param container - The container to search within
  * @param testId - The test ID or pattern to match
- * @param options - Text matching options (exact, normalizer)
+ * @param options - Text matching options (exact, normalizer, timeout)
  * @returns Promise resolving to array of matching widgets
  */
-export const findAllByTestId = async (container, testId, options) => waitFor(() => getAllByTestId(container, testId, options));
+export const findAllByTestId = async (container, testId, options) => waitFor(() => getAllByTestId(container, testId, options), { timeout: options?.timeout });

package/dist/render.js

@@ -1,19 +1,28 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { getCurrentApp, start, stop } from "@gtkx/ffi";
+import { getCurrentApp, getObject, start, stop } from "@gtkx/ffi";
 import * as Gtk from "@gtkx/ffi/gtk";
 import { ApplicationWindow, reconciler } from "@gtkx/react";
 import * as queries from "./queries.js";
 import { setScreenRoot } from "./screen.js";
 import { tick } from "./timing.js";
+import { asAccessible, hasLabel } from "./widget.js";
 const ROOT_NODE_CONTAINER = Symbol.for("ROOT_NODE_CONTAINER");
 const APP_ID = "com.gtkx.testing";
 let container = null;
-const hasGetLabel = (widget) => typeof widget.getLabel === "function";
-const asAccessible = (widget) => widget;
+const getWidgetLabel = (widget) => {
+    if (!hasLabel(widget))
+        return null;
+    const role = asAccessible(widget).getAccessibleRole();
+    if (role === Gtk.AccessibleRole.LABEL) {
+        return getObject(widget.ptr, Gtk.Label).getLabel();
+    }
+    return getObject(widget.ptr, Gtk.Button).getLabel();
+};
 const printWidgetTree = (root, indent = 0) => {
     const prefix = "  ".repeat(indent);
     const role = Gtk.AccessibleRole[asAccessible(root).getAccessibleRole()] ?? "UNKNOWN";
-    const label = hasGetLabel(root) ? ` label="${root.getLabel()}"` : "";
+    const labelText = getWidgetLabel(root);
+    const label = labelText ? ` label="${labelText}"` : "";
     let result = `${prefix}<${root.constructor.name} role=${role}${label}>\n`;
     let child = root.getFirstChild();
     while (child) {
@@ -94,5 +103,4 @@ export const cleanup = async () => {
 export const teardown = async () => {
     await cleanup();
     stop();
-    container = null;
 };

package/dist/types.d.ts

@@ -1,41 +1,87 @@
 import type * as Gtk from "@gtkx/ffi/gtk";
 import type { AccessibleRole } from "@gtkx/ffi/gtk";
 import type { ComponentType, ReactNode } from "react";
+/**
+ * Options for text matching in queries.
+ */
 export interface TextMatchOptions {
+    /** Whether to match the entire string exactly. Defaults to true. */
     exact?: boolean;
+    /** Custom function to normalize text before comparison. */
     normalizer?: (text: string) => string;
+    /** Maximum time in milliseconds to wait for a match. */
+    timeout?: number;
 }
+/**
+ * Options for querying elements by their accessible role.
+ */
 export interface ByRoleOptions extends TextMatchOptions {
+    /** Filter by the element's accessible name. */
     name?: string | RegExp;
+    /** Filter checkboxes/switches by checked state. */
     checked?: boolean;
+    /** Filter toggle buttons by pressed state. */
     pressed?: boolean;
+    /** Filter selectable items by selected state. */
     selected?: boolean;
+    /** Filter expandable elements by expanded state. */
     expanded?: boolean;
+    /** Filter headings by their level (1-6). */
     level?: number;
 }
+/**
+ * Options for waitFor and related async utilities.
+ */
 export interface WaitForOptions {
+    /** Maximum time in milliseconds to wait. Defaults to 1000ms. */
     timeout?: number;
+    /** Interval in milliseconds between condition checks. Defaults to 50ms. */
     interval?: number;
+    /** Custom error handler called when timeout is reached. */
     onTimeout?: (error: Error) => Error;
 }
+/**
+ * Options for the render function.
+ */
 export interface RenderOptions {
+    /** A React component to wrap the rendered element. Useful for providing context. */
     wrapper?: ComponentType<{
         children: ReactNode;
     }>;
 }
+/**
+ * Query methods bound to a specific container. All queries return promises
+ * that resolve when a matching element is found or reject on timeout.
+ */
 export interface BoundQueries {
+    /** Find a single element by its accessible role. */
     findByRole: (role: AccessibleRole, options?: ByRoleOptions) => Promise<Gtk.Widget>;
+    /** Find a single element by its associated label text. */
     findByLabelText: (text: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget>;
+    /** Find a single element by its text content. */
     findByText: (text: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget>;
+    /** Find a single element by its test ID. */
     findByTestId: (testId: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget>;
+    /** Find all elements matching an accessible role. */
     findAllByRole: (role: AccessibleRole, options?: ByRoleOptions) => Promise<Gtk.Widget[]>;
+    /** Find all elements with matching label text. */
     findAllByLabelText: (text: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget[]>;
+    /** Find all elements with matching text content. */
     findAllByText: (text: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget[]>;
+    /** Find all elements with matching test ID. */
     findAllByTestId: (testId: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget[]>;
 }
+/**
+ * The result returned by the render function. Includes query methods
+ * and utilities for interacting with the rendered component.
+ */
 export interface RenderResult extends BoundQueries {
+    /** The GTK Application instance containing the rendered component. */
     container: Gtk.Application;
+    /** Unmount the rendered component and clean up resources. */
     unmount: () => Promise<void>;
+    /** Re-render with a new element, preserving state where possible. */
     rerender: (element: ReactNode) => Promise<void>;
+    /** Print the current widget tree to the console for debugging. */
     debug: () => void;
 }

package/dist/user-event.d.ts

@@ -1,36 +1,23 @@
 import type * as Gtk from "@gtkx/ffi/gtk";
 /**
- * Options for configuring user event behavior.
+ * Options for the tab user event.
  */
-export interface UserEventOptions {
-    /** Delay between events in milliseconds */
-    delay?: number;
-}
-/**
- * Instance returned by userEvent.setup() with bound options.
- */
-export interface UserEventInstance {
-    /** Simulates a click on the element */
-    click: (element: Gtk.Widget) => Promise<void>;
-    /** Simulates a double-click on the element */
-    dblClick: (element: Gtk.Widget) => Promise<void>;
-    /** Activates the element (e.g., pressing Enter in an Entry) */
-    activate: (element: Gtk.Widget) => Promise<void>;
-    /** Types text into an input element */
-    type: (element: Gtk.Widget, text: string) => Promise<void>;
-    /** Clears the text content of an input element */
-    clear: (element: Gtk.Widget) => Promise<void>;
+export interface TabOptions {
+    /** If true, navigates backwards (Shift+Tab behavior). */
+    shift?: boolean;
 }
 /**
  * Simulates user interactions with GTK widgets. Provides methods that mimic
  * real user behavior like clicking, typing, and clearing input fields.
- * Use userEvent.setup() to create an instance with custom options.
  */
 export declare const userEvent: {
-    setup: (options?: UserEventOptions) => UserEventInstance;
     click: (element: Gtk.Widget) => Promise<void>;
     dblClick: (element: Gtk.Widget) => Promise<void>;
+    tripleClick: (element: Gtk.Widget) => Promise<void>;
     activate: (element: Gtk.Widget) => Promise<void>;
+    tab: (element: Gtk.Widget, options?: TabOptions) => Promise<void>;
     type: (element: Gtk.Widget, text: string) => Promise<void>;
     clear: (element: Gtk.Widget) => Promise<void>;
+    selectOptions: (element: Gtk.Widget, values: string | string[] | number | number[]) => Promise<void>;
+    deselectOptions: (element: Gtk.Widget, values: number | number[]) => Promise<void>;
 };

package/dist/user-event.js

@@ -1,73 +1,143 @@
+import { getObject } from "@gtkx/ffi";
+import { AccessibleRole, CheckButton, ComboBox, DirectionType, DropDown, Editable, ListBox, ListBoxRow, ToggleButton, Widget, } from "@gtkx/ffi/gtk";
 import { fireEvent } from "./fire-event.js";
 import { tick } from "./timing.js";
-import { hasGetText, hasSetText } from "./widget.js";
-const createUserEventInstance = (_options) => {
-    return {
-        click: async (element) => {
-            fireEvent(element, "clicked");
-            await tick();
-        },
-        dblClick: async (element) => {
-            fireEvent(element, "clicked");
-            await tick();
-            fireEvent(element, "clicked");
-            await tick();
-        },
-        activate: async (element) => {
-            element.activate();
-            await tick();
-        },
-        type: async (element, text) => {
-            if (!hasSetText(element)) {
-                throw new Error("Cannot type into element: no setText method available");
+import { asAccessible, isEditable } from "./widget.js";
+const TOGGLEABLE_ROLES = new Set([AccessibleRole.CHECKBOX, AccessibleRole.RADIO, AccessibleRole.TOGGLE_BUTTON]);
+const isToggleable = (widget) => {
+    const role = asAccessible(widget).getAccessibleRole();
+    return TOGGLEABLE_ROLES.has(role);
+};
+const click = async (element) => {
+    if (isToggleable(element)) {
+        const role = asAccessible(element).getAccessibleRole();
+        if (role === AccessibleRole.CHECKBOX || role === AccessibleRole.RADIO) {
+            const checkButton = getObject(element.ptr, CheckButton);
+            checkButton.setActive(!checkButton.getActive());
+        }
+        else {
+            const toggleButton = getObject(element.ptr, ToggleButton);
+            toggleButton.setActive(!toggleButton.getActive());
+        }
+        // Note: setActive() automatically emits the "toggled" signal, so we don't need to emit it manually
+    }
+    else {
+        fireEvent(element, "clicked");
+    }
+    await tick();
+};
+const dblClick = async (element) => {
+    fireEvent(element, "clicked");
+    await tick();
+    fireEvent(element, "clicked");
+    await tick();
+};
+const tripleClick = async (element) => {
+    fireEvent(element, "clicked");
+    await tick();
+    fireEvent(element, "clicked");
+    await tick();
+    fireEvent(element, "clicked");
+    await tick();
+};
+const activate = async (element) => {
+    element.activate();
+    await tick();
+};
+const tab = async (element, options) => {
+    const direction = options?.shift ? DirectionType.TAB_BACKWARD : DirectionType.TAB_FORWARD;
+    const root = element.getRoot();
+    if (root) {
+        const rootWidget = getObject(root.ptr, Widget);
+        rootWidget.childFocus(direction);
+    }
+    await tick();
+};
+const type = async (element, text) => {
+    if (!isEditable(element)) {
+        throw new Error("Cannot type into element: element is not editable (TEXT_BOX, SEARCH_BOX, or SPIN_BUTTON)");
+    }
+    const editable = getObject(element.ptr, Editable);
+    const currentText = editable.getText();
+    editable.setText(currentText + text);
+    await tick();
+};
+const clear = async (element) => {
+    if (!isEditable(element)) {
+        throw new Error("Cannot clear element: element is not editable (TEXT_BOX, SEARCH_BOX, or SPIN_BUTTON)");
+    }
+    const editable = getObject(element.ptr, Editable);
+    editable.setText("");
+    await tick();
+};
+const SELECTABLE_ROLES = new Set([AccessibleRole.COMBO_BOX, AccessibleRole.LIST]);
+const isSelectable = (widget) => {
+    const role = asAccessible(widget).getAccessibleRole();
+    return SELECTABLE_ROLES.has(role);
+};
+const selectOptions = async (element, values) => {
+    if (!isSelectable(element)) {
+        throw new Error("Cannot select options: element is not a selectable widget (COMBO_BOX or LIST)");
+    }
+    const role = asAccessible(element).getAccessibleRole();
+    const valueArray = Array.isArray(values) ? values : [values];
+    if (role === AccessibleRole.COMBO_BOX) {
+        if (valueArray.length > 1) {
+            throw new Error("Cannot select multiple options on a ComboBox/DropDown");
+        }
+        const value = valueArray[0];
+        if (typeof value !== "number") {
+            throw new Error("ComboBox/DropDown selection requires a numeric index");
+        }
+        const isDropDown = element.constructor.name === "DropDown";
+        if (isDropDown) {
+            getObject(element.ptr, DropDown).setSelected(value);
+        }
+        else {
+            getObject(element.ptr, ComboBox).setActive(value);
+        }
+    }
+    else if (role === AccessibleRole.LIST) {
+        const listBox = getObject(element.ptr, ListBox);
+        for (const value of valueArray) {
+            if (typeof value !== "number") {
+                throw new Error("ListBox selection requires numeric indices");
             }
-            const currentText = hasGetText(element) ? element.getText() : "";
-            element.setText(currentText + text);
-            await tick();
-        },
-        clear: async (element) => {
-            if (!hasSetText(element)) {
-                throw new Error("Cannot clear element: no setText method available");
+            const row = listBox.getRowAtIndex(value);
+            if (row) {
+                listBox.selectRow(row);
             }
-            element.setText("");
-            await tick();
-        },
-    };
+        }
+    }
+    await tick();
+};
+const deselectOptions = async (element, values) => {
+    const role = asAccessible(element).getAccessibleRole();
+    if (role !== AccessibleRole.LIST) {
+        throw new Error("Cannot deselect options: only ListBox supports deselection");
+    }
+    const listBox = getObject(element.ptr, ListBox);
+    const valueArray = Array.isArray(values) ? values : [values];
+    for (const value of valueArray) {
+        const row = listBox.getRowAtIndex(value);
+        if (row) {
+            listBox.unselectRow(getObject(row.ptr, ListBoxRow));
+        }
+    }
+    await tick();
 };
 /**
  * Simulates user interactions with GTK widgets. Provides methods that mimic
  * real user behavior like clicking, typing, and clearing input fields.
- * Use userEvent.setup() to create an instance with custom options.
  */
 export const userEvent = {
-    setup: (options) => createUserEventInstance(options),
-    click: async (element) => {
-        fireEvent(element, "clicked");
-        await tick();
-    },
-    dblClick: async (element) => {
-        fireEvent(element, "clicked");
-        await tick();
-        fireEvent(element, "clicked");
-        await tick();
-    },
-    activate: async (element) => {
-        element.activate();
-        await tick();
-    },
-    type: async (element, text) => {
-        if (!hasSetText(element)) {
-            throw new Error("Cannot type into element: no setText method available");
-        }
-        const currentText = hasGetText(element) ? element.getText() : "";
-        element.setText(currentText + text);
-        await tick();
-    },
-    clear: async (element) => {
-        if (!hasSetText(element)) {
-            throw new Error("Cannot clear element: no setText method available");
-        }
-        element.setText("");
-        await tick();
-    },
+    click,
+    dblClick,
+    tripleClick,
+    activate,
+    tab,
+    type,
+    clear,
+    selectOptions,
+    deselectOptions,
 };

package/dist/widget.d.ts

@@ -1,9 +1,5 @@
-type WidgetWithSetText = {
-    setText: (text: string) => void;
-};
-type WidgetWithGetText = {
-    getText: () => string;
-};
-export declare const hasSetText: (widget: unknown) => widget is WidgetWithSetText;
-export declare const hasGetText: (widget: unknown) => widget is WidgetWithGetText;
-export {};
+import type * as Gtk from "@gtkx/ffi/gtk";
+import { type Accessible } from "@gtkx/ffi/gtk";
+export declare const asAccessible: (widget: Gtk.Widget) => Accessible;
+export declare const isEditable: (widget: Gtk.Widget) => boolean;
+export declare const hasLabel: (widget: Gtk.Widget) => boolean;

package/dist/widget.js

@@ -1,2 +1,21 @@
-export const hasSetText = (widget) => typeof widget.setText === "function";
-export const hasGetText = (widget) => typeof widget.getText === "function";
+import { AccessibleRole } from "@gtkx/ffi/gtk";
+export const asAccessible = (widget) => widget;
+const EDITABLE_ROLES = new Set([AccessibleRole.TEXT_BOX, AccessibleRole.SEARCH_BOX, AccessibleRole.SPIN_BUTTON]);
+export const isEditable = (widget) => {
+    const role = asAccessible(widget).getAccessibleRole();
+    return EDITABLE_ROLES.has(role);
+};
+const LABEL_ROLES = new Set([
+    AccessibleRole.BUTTON,
+    AccessibleRole.TOGGLE_BUTTON,
+    AccessibleRole.CHECKBOX,
+    AccessibleRole.RADIO,
+    AccessibleRole.LABEL,
+    AccessibleRole.MENU_ITEM,
+    AccessibleRole.MENU_ITEM_CHECKBOX,
+    AccessibleRole.MENU_ITEM_RADIO,
+]);
+export const hasLabel = (widget) => {
+    const role = asAccessible(widget).getAccessibleRole();
+    return LABEL_ROLES.has(role);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/testing",
-  "version": "0.1.49",
+  "version": "0.1.51",
   "description": "Testing utilities for GTKX applications",
   "keywords": [
     "gtk",
@@ -32,9 +32,9 @@
     "dist"
   ],
   "dependencies": {
-    "@gtkx/ffi": "0.1.49",
-    "@gtkx/native": "0.1.49",
-    "@gtkx/react": "0.1.49"
+    "@gtkx/ffi": "0.1.51",
+    "@gtkx/react": "0.1.51",
+    "@gtkx/native": "0.1.51"
   },
   "scripts": {
     "build": "tsc -b && cp ../../README.md .",