@gtkx/testing 0.1.48 → 0.1.50

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;
@@ -23,43 +24,70 @@ 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 = widget;
+    const accessible = asAccessible(widget);
     if (accessible.getAccessibleRole() !== AccessibleRole.LABEL)
         return false;
     const parent = widget.getParent();
     if (!parent)
         return false;
-    const parentAccessible = parent;
-    const parentRole = parentAccessible.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);
+    const parentRole = asAccessible(parent).getAccessibleRole();
+    return ROLES_WITH_INTERNAL_LABELS.has(parentRole);
 };
 const getWidgetText = (widget) => {
     if (isInternalLabel(widget))
         return null;
-    const accessible = widget;
-    const role = accessible.getAccessibleRole();
+    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;
     }
@@ -67,20 +95,23 @@ const getWidgetText = (widget) => {
 const getWidgetTestId = (widget) => {
     return widget.getName();
 };
+const asSwitch = (widget) => getObject(widget.ptr, Switch);
 const getWidgetCheckedState = (widget) => {
-    const accessible = widget;
-    const role = accessible.getAccessibleRole();
-    if (role === AccessibleRole.CHECKBOX || role === AccessibleRole.RADIO) {
-        return asCheckButton(widget).getActive();
-    }
-    if (role === AccessibleRole.TOGGLE_BUTTON) {
-        return asToggleButton(widget).getActive();
+    const role = asAccessible(widget).getAccessibleRole();
+    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 accessible = widget;
-    const role = accessible.getAccessibleRole();
+    const role = asAccessible(widget).getAccessibleRole();
     if (role === AccessibleRole.BUTTON) {
         const parent = widget.getParent();
         if (!parent)
@@ -128,8 +159,7 @@ const formatByRoleError = (role, options) => {
 };
 const getAllByRole = (container, role, options) => {
     const matches = findAll(container, (node) => {
-        const accessible = node;
-        if (accessible.getAccessibleRole() !== role)
+        if (asAccessible(node).getAccessibleRole() !== role)
             return false;
         return matchByRoleOptions(node, options);
     });
@@ -143,7 +173,10 @@ const getByRole = (container, role, options) => {
     if (matches.length > 1) {
         throw new Error(`Found ${matches.length} elements with ${formatByRoleError(role, options)}`);
     }
-    return matches[0];
+    const [first] = matches;
+    if (!first)
+        throw new Error(`Unable to find element with ${formatByRoleError(role, options)}`);
+    return first;
 };
 const getAllByLabelText = (container, text, options) => {
     const matches = findAll(container, (node) => {
@@ -160,7 +193,10 @@ const getByLabelText = (container, text, options) => {
     if (matches.length > 1) {
         throw new Error(`Found ${matches.length} elements with label text "${text}"`);
     }
-    return matches[0];
+    const [first] = matches;
+    if (!first)
+        throw new Error(`Unable to find element with label text "${text}"`);
+    return first;
 };
 const getAllByText = (container, text, options) => {
     const matches = findAll(container, (node) => {
@@ -177,7 +213,10 @@ const getByText = (container, text, options) => {
     if (matches.length > 1) {
         throw new Error(`Found ${matches.length} elements with text "${text}"`);
     }
-    return matches[0];
+    const [first] = matches;
+    if (!first)
+        throw new Error(`Unable to find element with text "${text}"`);
+    return first;
 };
 const getAllByTestId = (container, testId, options) => {
     const matches = findAll(container, (node) => {
@@ -194,7 +233,10 @@ const getByTestId = (container, testId, options) => {
     if (matches.length > 1) {
         throw new Error(`Found ${matches.length} elements with test id "${testId}"`);
     }
-    return matches[0];
+    const [first] = matches;
+    if (!first)
+        throw new Error(`Unable to find element with test id "${testId}"`);
+    return first;
 };
 /**
  * Waits for and finds a single widget matching the specified accessible role.
@@ -203,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
@@ -211,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,18 +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 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 accessible = root;
     const prefix = "  ".repeat(indent);
-    const role = Gtk.AccessibleRole[accessible.getAccessibleRole()] ?? "UNKNOWN";
-    const label = hasGetLabel(root) ? ` label="${root.getLabel()}"` : "";
+    const role = Gtk.AccessibleRole[asAccessible(root).getAccessibleRole()] ?? "UNKNOWN";
+    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) {
@@ -21,7 +31,6 @@ const printWidgetTree = (root, indent = 0) => {
     }
     return result;
 };
-const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
 const update = async (instance, element, fiberRoot) => {
     instance.updateContainer(element, fiberRoot, null, () => { });
     await tick();
@@ -30,9 +39,7 @@ const ensureInitialized = () => {
     const app = start(APP_ID);
     if (!container) {
         const instance = reconciler.getInstance();
-        container = instance.createContainer(
-        // biome-ignore lint/suspicious/noExplicitAny: testing only
-        ROOT_NODE_CONTAINER, 0, null, false, null, "", (error) => console.error("Test reconciler error:", error), () => { }, () => { }, () => { }, null);
+        container = instance.createContainer(ROOT_NODE_CONTAINER, 0, null, false, null, "", (error) => console.error("Test reconciler error:", error), () => { }, () => { }, () => { }, null);
     }
     return { app, container };
 };
@@ -96,5 +103,4 @@ export const cleanup = async () => {
 export const teardown = async () => {
     await cleanup();
     stop();
-    container = null;
 };

package/dist/timing.d.ts

@@ -0,0 +1 @@
+export declare const tick: () => Promise<void>;

package/dist/timing.js

@@ -0,0 +1 @@
+export const tick = () => new Promise((resolve) => setTimeout(resolve, 0));

package/dist/types.d.ts

@@ -4,6 +4,7 @@ import type { ComponentType, ReactNode } from "react";
 export interface TextMatchOptions {
     exact?: boolean;
     normalizer?: (text: string) => string;
+    timeout?: number;
 }
 export interface ByRoleOptions extends TextMatchOptions {
     name?: string | RegExp;

package/dist/user-event.d.ts

@@ -1,36 +1,20 @@
 import type * as Gtk from "@gtkx/ffi/gtk";
-/**
- * Options for configuring user event behavior.
- */
-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 { hasGetText, hasSetText } from "./widget.js";
-const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
-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 { tick } from "./timing.js";
+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.48",
+  "version": "0.1.50",
   "description": "Testing utilities for GTKX applications",
   "keywords": [
     "gtk",
@@ -32,9 +32,9 @@
     "dist"
   ],
   "dependencies": {
-    "@gtkx/native": "0.1.48",
-    "@gtkx/ffi": "0.1.48",
-    "@gtkx/react": "0.1.48"
+    "@gtkx/react": "0.1.50",
+    "@gtkx/ffi": "0.1.50",
+    "@gtkx/native": "0.1.50"
   },
   "scripts": {
     "build": "tsc -b && cp ../../README.md .",