@gtkx/testing 0.1.32 → 0.1.34

package/README.md

@@ -119,10 +119,12 @@ import { AccessibleRole } from "@gtkx/ffi/gtk";
 import { App } from "./app.js";
 
 // Clean up after each test
-afterEach(() => cleanup());
+afterEach(async () => {
+  await cleanup();
+});
 
 test("increments count when clicking button", async () => {
-  render(<App />);
+  await render(<App />);
 
   const button = await screen.findByRole(AccessibleRole.BUTTON, {
     name: "Increment",
@@ -132,8 +134,8 @@ test("increments count when clicking button", async () => {
   await screen.findByText("Count: 1");
 });
 
-test("can also use fireEvent for synchronous events", async () => {
-  render(<App />);
+test("can also use fireEvent for low-level events", async () => {
+  await render(<App />);
 
   const button = await screen.findByRole(AccessibleRole.BUTTON, {
     name: "Increment",
@@ -146,10 +148,8 @@ test("can also use fireEvent for synchronous events", async () => {
 
 ### Available APIs
 
-**Queries** - Find elements in the rendered tree:
-- `getBy*` / `getAllBy*` - Throws if not found
-- `queryBy*` / `queryAllBy*` - Returns null/empty array if not found
-- `findBy*` / `findAllBy*` - Async, waits for element
+**Queries** - Find elements in the rendered tree (all async):
+- `findBy*` / `findAllBy*` - Waits for element to appear
 
 Query types: `ByRole`, `ByText`, `ByLabelText`, `ByTestId`
 

package/dist/fire-event.js

@@ -1,22 +1,45 @@
 import { call } from "@gtkx/native";
-import { getWidgetPtr } from "./widget.js";
+const hasToggle = (widget) => "getActive" in widget &&
+    typeof widget.getActive === "function" &&
+    "setActive" in widget &&
+    typeof widget.setActive === "function";
 const emitSignal = (widget, signalName) => {
     call("libgobject-2.0.so.0", "g_signal_emit_by_name", [
-        { type: { type: "gobject" }, value: getWidgetPtr(widget) },
+        { type: { type: "gobject" }, value: widget.ptr },
         { type: { type: "string" }, value: signalName },
     ], { type: "undefined" });
 };
 export const fireEvent = Object.assign((element, signalName) => {
-    emitSignal(element, signalName);
+    switch (signalName) {
+        case "clicked":
+            emitSignal(element, "clicked");
+            break;
+        case "activate":
+            element.activate();
+            break;
+        case "toggled":
+            if (hasToggle(element)) {
+                element.setActive(!element.getActive());
+            }
+            break;
+        case "changed":
+            emitSignal(element, "changed");
+            break;
+        default:
+            throw new Error(`fireEvent: Signal "${signalName}" is not supported. ` +
+                `Supported signals: clicked, activate, toggled, changed`);
+    }
 }, {
     click: (element) => {
         emitSignal(element, "clicked");
     },
     activate: (element) => {
-        emitSignal(element, "activate");
+        element.activate();
     },
     toggled: (element) => {
-        emitSignal(element, "toggled");
+        if (hasToggle(element)) {
+            element.setActive(!element.getActive());
+        }
     },
     changed: (element) => {
         emitSignal(element, "changed");

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { fireEvent } from "./fire-event.js";
-export { findAllByLabelText, findAllByRole, findAllByTestId, findAllByText, findByLabelText, findByRole, findByTestId, findByText, getAllByLabelText, getAllByRole, getAllByTestId, getAllByText, getByLabelText, getByRole, getByTestId, getByText, queryAllByLabelText, queryAllByRole, queryAllByTestId, queryAllByText, queryByLabelText, queryByRole, queryByTestId, queryByText, } from "./queries.js";
+export { findAllByLabelText, findAllByRole, findAllByTestId, findAllByText, findByLabelText, findByRole, findByTestId, findByText, } from "./queries.js";
 export { cleanup, render, teardown } from "./render.js";
 export { screen } from "./screen.js";
 export type { ByRoleOptions, RenderOptions, RenderResult, TextMatchOptions, WaitForOptions, } from "./types.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 export { fireEvent } from "./fire-event.js";
-export { findAllByLabelText, findAllByRole, findAllByTestId, findAllByText, findByLabelText, findByRole, findByTestId, findByText, getAllByLabelText, getAllByRole, getAllByTestId, getAllByText, getByLabelText, getByRole, getByTestId, getByText, queryAllByLabelText, queryAllByRole, queryAllByTestId, queryAllByText, queryByLabelText, queryByRole, queryByTestId, queryByText, } from "./queries.js";
+export { findAllByLabelText, findAllByRole, findAllByTestId, findAllByText, findByLabelText, findByRole, findByTestId, findByText, } from "./queries.js";
 export { cleanup, render, teardown } from "./render.js";
 export { screen } from "./screen.js";
 export { userEvent } from "./user-event.js";

package/dist/queries.d.ts

@@ -2,22 +2,6 @@ import type * as Gtk from "@gtkx/ffi/gtk";
 import { AccessibleRole } from "@gtkx/ffi/gtk";
 import type { ByRoleOptions, TextMatchOptions } from "./types.js";
 type Container = Gtk.Application | Gtk.Widget;
-export declare const getAllByRole: (container: Container, role: AccessibleRole, options?: ByRoleOptions) => Gtk.Widget[];
-export declare const getByRole: (container: Container, role: AccessibleRole, options?: ByRoleOptions) => Gtk.Widget;
-export declare const queryAllByRole: (container: Container, role: AccessibleRole, options?: ByRoleOptions) => Gtk.Widget[];
-export declare const queryByRole: (container: Container, role: AccessibleRole, options?: ByRoleOptions) => Gtk.Widget | null;
-export declare const getAllByLabelText: (container: Container, text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget[];
-export declare const getByLabelText: (container: Container, text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget;
-export declare const queryAllByLabelText: (container: Container, text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget[];
-export declare const queryByLabelText: (container: Container, text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget | null;
-export declare const getAllByText: (container: Container, text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget[];
-export declare const getByText: (container: Container, text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget;
-export declare const queryAllByText: (container: Container, text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget[];
-export declare const queryByText: (container: Container, text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget | null;
-export declare const getAllByTestId: (container: Container, testId: string | RegExp, options?: TextMatchOptions) => Gtk.Widget[];
-export declare const getByTestId: (container: Container, testId: string | RegExp, options?: TextMatchOptions) => Gtk.Widget;
-export declare const queryAllByTestId: (container: Container, testId: string | RegExp, options?: TextMatchOptions) => Gtk.Widget[];
-export declare const queryByTestId: (container: Container, testId: string | RegExp, options?: TextMatchOptions) => Gtk.Widget | null;
 export declare const findByRole: (container: Container, role: AccessibleRole, options?: ByRoleOptions) => Promise<Gtk.Widget>;
 export declare const findAllByRole: (container: Container, role: AccessibleRole, options?: ByRoleOptions) => Promise<Gtk.Widget[]>;
 export declare const findByLabelText: (container: Container, text: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget>;

package/dist/queries.js

@@ -1,8 +1,7 @@
-import { AccessibleRole } from "@gtkx/ffi/gtk";
-import { call } from "@gtkx/native";
+import { wrapPtr } from "@gtkx/ffi";
+import { AccessibleRole, Button, CheckButton, Expander, Label, ToggleButton } from "@gtkx/ffi/gtk";
 import { findAll } from "./traversal.js";
 import { waitFor } from "./wait-for.js";
-import { getWidgetPtr } from "./widget.js";
 const DEFAULT_NORMALIZER = (text) => text.trim().replace(/\s+/g, " ");
 const normalizeText = (text, options) => {
     const normalizer = options?.normalizer ?? DEFAULT_NORMALIZER;
@@ -19,13 +18,11 @@ const matchText = (actual, expected, options) => {
     }
     return expected.test(normalizedActual);
 };
-const callGetter = (ptr, funcName) => {
-    const result = call("libgtk-4.so.1", funcName, [{ type: { type: "gobject" }, value: ptr }], {
-        type: "string",
-        borrowed: true,
-    });
-    return result;
-};
+const asButton = (widget) => wrapPtr(widget.ptr, Button);
+const asLabel = (widget) => wrapPtr(widget.ptr, Label);
+const asCheckButton = (widget) => wrapPtr(widget.ptr, CheckButton);
+const asToggleButton = (widget) => wrapPtr(widget.ptr, ToggleButton);
+const asExpander = (widget) => wrapPtr(widget.ptr, Expander);
 const isInternalLabel = (widget) => {
     const accessible = widget;
     if (accessible.getAccessibleRole() !== AccessibleRole.LABEL)
@@ -44,9 +41,6 @@ const isInternalLabel = (widget) => {
         parentRole === AccessibleRole.MENU_ITEM_RADIO);
 };
 const getWidgetText = (widget) => {
-    const ptr = getWidgetPtr(widget);
-    if (!ptr)
-        return null;
     if (isInternalLabel(widget))
         return null;
     const accessible = widget;
@@ -59,57 +53,39 @@ const getWidgetText = (widget) => {
         case AccessibleRole.MENU_ITEM:
         case AccessibleRole.MENU_ITEM_CHECKBOX:
         case AccessibleRole.MENU_ITEM_RADIO:
-            return callGetter(ptr, "gtk_button_get_label");
+            return asButton(widget).getLabel();
         case AccessibleRole.LABEL:
-            return callGetter(ptr, "gtk_label_get_label");
+            return asLabel(widget).getLabel();
         case AccessibleRole.TEXT_BOX:
         case AccessibleRole.SEARCH_BOX:
         case AccessibleRole.SPIN_BUTTON:
-            return callGetter(ptr, "gtk_editable_get_text");
+            return widget.getText();
         default:
             return null;
     }
 };
 const getWidgetTestId = (widget) => {
-    const ptr = getWidgetPtr(widget);
-    if (!ptr)
-        return null;
-    const result = call("libgtk-4.so.1", "gtk_widget_get_name", [{ type: { type: "gobject" }, value: ptr }], {
-        type: "string",
-        borrowed: true,
-    });
-    return result;
+    return widget.getName();
 };
 const getWidgetCheckedState = (widget) => {
-    const ptr = getWidgetPtr(widget);
-    if (!ptr)
-        return undefined;
     const accessible = widget;
     const role = accessible.getAccessibleRole();
     if (role === AccessibleRole.CHECKBOX || role === AccessibleRole.RADIO) {
-        const result = call("libgtk-4.so.1", "gtk_check_button_get_active", [{ type: { type: "gobject" }, value: ptr }], {
-            type: "boolean",
-        });
-        return result === true;
+        return asCheckButton(widget).getActive();
     }
     if (role === AccessibleRole.TOGGLE_BUTTON) {
-        const result = call("libgtk-4.so.1", "gtk_toggle_button_get_active", [{ type: { type: "gobject" }, value: ptr }], { type: "boolean" });
-        return result === true;
+        return asToggleButton(widget).getActive();
     }
     return undefined;
 };
 const getWidgetExpandedState = (widget) => {
-    const ptr = getWidgetPtr(widget);
-    if (!ptr)
-        return undefined;
     const accessible = widget;
     const role = accessible.getAccessibleRole();
     if (role === AccessibleRole.BUTTON) {
-        const expanderPtr = call("libgtk-4.so.1", "gtk_widget_get_parent", [{ type: { type: "gobject" }, value: ptr }], { type: "gobject" });
-        if (!expanderPtr)
+        const parent = widget.getParent();
+        if (!parent)
             return undefined;
-        const result = call("libgtk-4.so.1", "gtk_expander_get_expanded", [{ type: { type: "gobject" }, value: expanderPtr }], { type: "boolean" });
-        return result === true;
+        return asExpander(parent).getExpanded();
     }
     return undefined;
 };
@@ -150,7 +126,7 @@ const formatByRoleError = (role, options) => {
         parts.push(`level=${options.level}`);
     return parts.join(" and ");
 };
-export const getAllByRole = (container, role, options) => {
+const getAllByRole = (container, role, options) => {
     const matches = findAll(container, (node) => {
         const accessible = node;
         if (accessible.getAccessibleRole() !== role)
@@ -162,29 +138,14 @@ export const getAllByRole = (container, role, options) => {
     }
     return matches;
 };
-export const getByRole = (container, role, options) => {
+const getByRole = (container, role, options) => {
     const matches = getAllByRole(container, role, options);
     if (matches.length > 1) {
         throw new Error(`Found ${matches.length} elements with ${formatByRoleError(role, options)}`);
     }
     return matches[0];
 };
-export const queryAllByRole = (container, role, options) => {
-    return findAll(container, (node) => {
-        const accessible = node;
-        if (accessible.getAccessibleRole() !== role)
-            return false;
-        return matchByRoleOptions(node, options);
-    });
-};
-export const queryByRole = (container, role, options) => {
-    const matches = queryAllByRole(container, role, options);
-    if (matches.length > 1) {
-        throw new Error(`Found ${matches.length} elements with ${formatByRoleError(role, options)}`);
-    }
-    return matches[0] ?? null;
-};
-export const getAllByLabelText = (container, text, options) => {
+const getAllByLabelText = (container, text, options) => {
     const matches = findAll(container, (node) => {
         const widgetText = getWidgetText(node);
         return matchText(widgetText, text, options);
@@ -194,27 +155,14 @@ export const getAllByLabelText = (container, text, options) => {
     }
     return matches;
 };
-export const getByLabelText = (container, text, options) => {
+const getByLabelText = (container, text, options) => {
     const matches = getAllByLabelText(container, text, options);
     if (matches.length > 1) {
         throw new Error(`Found ${matches.length} elements with label text "${text}"`);
     }
     return matches[0];
 };
-export const queryAllByLabelText = (container, text, options) => {
-    return findAll(container, (node) => {
-        const widgetText = getWidgetText(node);
-        return matchText(widgetText, text, options);
-    });
-};
-export const queryByLabelText = (container, text, options) => {
-    const matches = queryAllByLabelText(container, text, options);
-    if (matches.length > 1) {
-        throw new Error(`Found ${matches.length} elements with label text "${text}"`);
-    }
-    return matches[0] ?? null;
-};
-export const getAllByText = (container, text, options) => {
+const getAllByText = (container, text, options) => {
     const matches = findAll(container, (node) => {
         const widgetText = getWidgetText(node);
         return matchText(widgetText, text, options);
@@ -224,27 +172,14 @@ export const getAllByText = (container, text, options) => {
     }
     return matches;
 };
-export const getByText = (container, text, options) => {
+const getByText = (container, text, options) => {
     const matches = getAllByText(container, text, options);
     if (matches.length > 1) {
         throw new Error(`Found ${matches.length} elements with text "${text}"`);
     }
     return matches[0];
 };
-export const queryAllByText = (container, text, options) => {
-    return findAll(container, (node) => {
-        const widgetText = getWidgetText(node);
-        return matchText(widgetText, text, options);
-    });
-};
-export const queryByText = (container, text, options) => {
-    const matches = queryAllByText(container, text, options);
-    if (matches.length > 1) {
-        throw new Error(`Found ${matches.length} elements with text "${text}"`);
-    }
-    return matches[0] ?? null;
-};
-export const getAllByTestId = (container, testId, options) => {
+const getAllByTestId = (container, testId, options) => {
     const matches = findAll(container, (node) => {
         const widgetTestId = getWidgetTestId(node);
         return matchText(widgetTestId, testId, options);
@@ -254,26 +189,13 @@ export const getAllByTestId = (container, testId, options) => {
     }
     return matches;
 };
-export const getByTestId = (container, testId, options) => {
+const getByTestId = (container, testId, options) => {
     const matches = getAllByTestId(container, testId, options);
     if (matches.length > 1) {
         throw new Error(`Found ${matches.length} elements with test id "${testId}"`);
     }
     return matches[0];
 };
-export const queryAllByTestId = (container, testId, options) => {
-    return findAll(container, (node) => {
-        const widgetTestId = getWidgetTestId(node);
-        return matchText(widgetTestId, testId, options);
-    });
-};
-export const queryByTestId = (container, testId, options) => {
-    const matches = queryAllByTestId(container, testId, options);
-    if (matches.length > 1) {
-        throw new Error(`Found ${matches.length} elements with test id "${testId}"`);
-    }
-    return matches[0] ?? null;
-};
 export const findByRole = async (container, role, options) => waitFor(() => getByRole(container, role, options));
 export const findAllByRole = async (container, role, options) => waitFor(() => getAllByRole(container, role, options));
 export const findByLabelText = async (container, text, options) => waitFor(() => getByLabelText(container, text, options));

package/dist/render.d.ts

@@ -1,5 +1,5 @@
 import type { ReactNode } from "react";
 import type { RenderOptions, RenderResult } from "./types.js";
-export declare const render: (element: ReactNode, options?: RenderOptions) => RenderResult;
-export declare const cleanup: () => void;
-export declare const teardown: () => void;
+export declare const render: (element: ReactNode, options?: RenderOptions) => Promise<RenderResult>;
+export declare const cleanup: () => Promise<void>;
+export declare const teardown: () => Promise<void>;

package/dist/render.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { start, stop } from "@gtkx/ffi";
 import * as Gtk from "@gtkx/ffi/gtk";
-import { reconciler } from "@gtkx/react";
+import { ApplicationWindow, reconciler } from "@gtkx/react";
 import * as queries from "./queries.js";
 import { setScreenRoot } from "./screen.js";
 const APP_ID = "com.gtkx.testing";
@@ -21,25 +21,10 @@ const printWidgetTree = (root, indent = 0) => {
     }
     return result;
 };
-const updateSync = (instance, element, fiberRoot) => {
-    const instanceAny = instance;
-    if (typeof instanceAny.flushSync === "function") {
-        instanceAny.flushSync(() => {
-            instance.updateContainer(element, fiberRoot, null, () => { });
-        });
-    }
-    else {
-        if (typeof instanceAny.updateContainerSync === "function") {
-            instanceAny.updateContainerSync(element, fiberRoot, null, () => { });
-        }
-        else {
-            instance.updateContainer(element, fiberRoot, null, () => { });
-        }
-        if (typeof instanceAny.flushSyncWork === "function") {
-            instanceAny.flushSyncWork();
-        }
-    }
-    instance.flushPassiveEffects();
+const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
+const update = async (instance, element, fiberRoot) => {
+    instance.updateContainer(element, fiberRoot, null, () => { });
+    await tick();
 };
 const ensureInitialized = () => {
     if (!app) {
@@ -57,35 +42,16 @@ const ensureInitialized = () => {
     }
     return { app, container };
 };
-const wrapElement = (element, Wrapper) => {
-    if (!Wrapper)
-        return element;
-    return _jsx(Wrapper, { children: element });
-};
-export const render = (element, options) => {
+const DefaultWrapper = ({ children }) => (_jsx(ApplicationWindow, { children: children }));
+const wrapElement = (element, Wrapper = DefaultWrapper) => (_jsx(Wrapper, { children: element }));
+export const render = async (element, options) => {
     const { app: application, container: fiberRoot } = ensureInitialized();
     const instance = reconciler.getInstance();
     const wrappedElement = wrapElement(element, options?.wrapper);
-    updateSync(instance, wrappedElement, fiberRoot);
+    await update(instance, wrappedElement, fiberRoot);
     setScreenRoot(application);
     return {
         container: application,
-        getByRole: (role, opts) => queries.getByRole(application, role, opts),
-        getByLabelText: (text, opts) => queries.getByLabelText(application, text, opts),
-        getByText: (text, opts) => queries.getByText(application, text, opts),
-        getByTestId: (testId, opts) => queries.getByTestId(application, testId, opts),
-        queryByRole: (role, opts) => queries.queryByRole(application, role, opts),
-        queryByLabelText: (text, opts) => queries.queryByLabelText(application, text, opts),
-        queryByText: (text, opts) => queries.queryByText(application, text, opts),
-        queryByTestId: (testId, opts) => queries.queryByTestId(application, testId, opts),
-        getAllByRole: (role, opts) => queries.getAllByRole(application, role, opts),
-        getAllByLabelText: (text, opts) => queries.getAllByLabelText(application, text, opts),
-        getAllByText: (text, opts) => queries.getAllByText(application, text, opts),
-        getAllByTestId: (testId, opts) => queries.getAllByTestId(application, testId, opts),
-        queryAllByRole: (role, opts) => queries.queryAllByRole(application, role, opts),
-        queryAllByLabelText: (text, opts) => queries.queryAllByLabelText(application, text, opts),
-        queryAllByText: (text, opts) => queries.queryAllByText(application, text, opts),
-        queryAllByTestId: (testId, opts) => queries.queryAllByTestId(application, testId, opts),
         findByRole: (role, opts) => queries.findByRole(application, role, opts),
         findByLabelText: (text, opts) => queries.findByLabelText(application, text, opts),
         findByText: (text, opts) => queries.findByText(application, text, opts),
@@ -94,10 +60,10 @@ export const render = (element, options) => {
         findAllByLabelText: (text, opts) => queries.findAllByLabelText(application, text, opts),
         findAllByText: (text, opts) => queries.findAllByText(application, text, opts),
         findAllByTestId: (testId, opts) => queries.findAllByTestId(application, testId, opts),
-        unmount: () => updateSync(instance, null, fiberRoot),
+        unmount: () => update(instance, null, fiberRoot),
         rerender: (newElement) => {
             const wrapped = wrapElement(newElement, options?.wrapper);
-            updateSync(instance, wrapped, fiberRoot);
+            return update(instance, wrapped, fiberRoot);
         },
         debug: () => {
             const activeWindow = application.getActiveWindow();
@@ -107,10 +73,10 @@ export const render = (element, options) => {
         },
     };
 };
-export const cleanup = () => {
+export const cleanup = async () => {
     if (container && app) {
         const instance = reconciler.getInstance();
-        updateSync(instance, null, container);
+        await update(instance, null, container);
         for (const window of app.getWindows()) {
             window.destroy();
         }
@@ -118,9 +84,9 @@ export const cleanup = () => {
     container = null;
     setScreenRoot(null);
 };
-export const teardown = () => {
+export const teardown = async () => {
     if (app) {
-        cleanup();
+        await cleanup();
         stop();
         app = null;
         container = null;

package/dist/screen.d.ts

@@ -3,22 +3,6 @@ import type { AccessibleRole } from "@gtkx/ffi/gtk";
 import type { ByRoleOptions, TextMatchOptions } from "./types.js";
 export declare const setScreenRoot: (root: Gtk.Application | null) => void;
 export declare const screen: {
-    getByRole: (role: AccessibleRole, options?: ByRoleOptions) => Gtk.Widget;
-    getByLabelText: (text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget;
-    getByText: (text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget;
-    getByTestId: (testId: string | RegExp, options?: TextMatchOptions) => Gtk.Widget;
-    queryByRole: (role: AccessibleRole, options?: ByRoleOptions) => Gtk.Widget | null;
-    queryByLabelText: (text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget | null;
-    queryByText: (text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget | null;
-    queryByTestId: (testId: string | RegExp, options?: TextMatchOptions) => Gtk.Widget | null;
-    getAllByRole: (role: AccessibleRole, options?: ByRoleOptions) => Gtk.Widget[];
-    getAllByLabelText: (text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget[];
-    getAllByText: (text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget[];
-    getAllByTestId: (testId: string | RegExp, options?: TextMatchOptions) => Gtk.Widget[];
-    queryAllByRole: (role: AccessibleRole, options?: ByRoleOptions) => Gtk.Widget[];
-    queryAllByLabelText: (text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget[];
-    queryAllByText: (text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget[];
-    queryAllByTestId: (testId: string | RegExp, options?: TextMatchOptions) => Gtk.Widget[];
     findByRole: (role: AccessibleRole, options?: ByRoleOptions) => Promise<Gtk.Widget>;
     findByLabelText: (text: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget>;
     findByText: (text: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget>;

package/dist/screen.js

@@ -10,22 +10,6 @@ const getRoot = () => {
     return currentRoot;
 };
 export const screen = {
-    getByRole: (role, options) => queries.getByRole(getRoot(), role, options),
-    getByLabelText: (text, options) => queries.getByLabelText(getRoot(), text, options),
-    getByText: (text, options) => queries.getByText(getRoot(), text, options),
-    getByTestId: (testId, options) => queries.getByTestId(getRoot(), testId, options),
-    queryByRole: (role, options) => queries.queryByRole(getRoot(), role, options),
-    queryByLabelText: (text, options) => queries.queryByLabelText(getRoot(), text, options),
-    queryByText: (text, options) => queries.queryByText(getRoot(), text, options),
-    queryByTestId: (testId, options) => queries.queryByTestId(getRoot(), testId, options),
-    getAllByRole: (role, options) => queries.getAllByRole(getRoot(), role, options),
-    getAllByLabelText: (text, options) => queries.getAllByLabelText(getRoot(), text, options),
-    getAllByText: (text, options) => queries.getAllByText(getRoot(), text, options),
-    getAllByTestId: (testId, options) => queries.getAllByTestId(getRoot(), testId, options),
-    queryAllByRole: (role, options) => queries.queryAllByRole(getRoot(), role, options),
-    queryAllByLabelText: (text, options) => queries.queryAllByLabelText(getRoot(), text, options),
-    queryAllByText: (text, options) => queries.queryAllByText(getRoot(), text, options),
-    queryAllByTestId: (testId, options) => queries.queryAllByTestId(getRoot(), testId, options),
     findByRole: (role, options) => queries.findByRole(getRoot(), role, options),
     findByLabelText: (text, options) => queries.findByLabelText(getRoot(), text, options),
     findByText: (text, options) => queries.findByText(getRoot(), text, options),

package/dist/types.d.ts

@@ -25,22 +25,6 @@ export interface RenderOptions {
 }
 export interface RenderResult {
     container: Gtk.Application;
-    getByRole: (role: AccessibleRole, options?: ByRoleOptions) => Gtk.Widget;
-    getByLabelText: (text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget;
-    getByText: (text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget;
-    getByTestId: (testId: string | RegExp, options?: TextMatchOptions) => Gtk.Widget;
-    queryByRole: (role: AccessibleRole, options?: ByRoleOptions) => Gtk.Widget | null;
-    queryByLabelText: (text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget | null;
-    queryByText: (text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget | null;
-    queryByTestId: (testId: string | RegExp, options?: TextMatchOptions) => Gtk.Widget | null;
-    getAllByRole: (role: AccessibleRole, options?: ByRoleOptions) => Gtk.Widget[];
-    getAllByLabelText: (text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget[];
-    getAllByText: (text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget[];
-    getAllByTestId: (testId: string | RegExp, options?: TextMatchOptions) => Gtk.Widget[];
-    queryAllByRole: (role: AccessibleRole, options?: ByRoleOptions) => Gtk.Widget[];
-    queryAllByLabelText: (text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget[];
-    queryAllByText: (text: string | RegExp, options?: TextMatchOptions) => Gtk.Widget[];
-    queryAllByTestId: (testId: string | RegExp, options?: TextMatchOptions) => Gtk.Widget[];
     findByRole: (role: AccessibleRole, options?: ByRoleOptions) => Promise<Gtk.Widget>;
     findByLabelText: (text: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget>;
     findByText: (text: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget>;
@@ -49,7 +33,7 @@ export interface RenderResult {
     findAllByLabelText: (text: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget[]>;
     findAllByText: (text: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget[]>;
     findAllByTestId: (testId: string | RegExp, options?: TextMatchOptions) => Promise<Gtk.Widget[]>;
-    unmount: () => void;
-    rerender: (element: ReactNode) => void;
+    unmount: () => Promise<void>;
+    rerender: (element: ReactNode) => Promise<void>;
     debug: () => void;
 }

package/dist/user-event.js

@@ -1,8 +1,9 @@
 import { call } from "@gtkx/native";
-import { getWidgetPtr, hasGetText, hasSetText } from "./widget.js";
+import { hasGetText, hasSetText } from "./widget.js";
+const tick = () => new Promise((resolve) => setTimeout(resolve, 0));
 const emitSignal = (widget, signalName) => {
     call("libgobject-2.0.so.0", "g_signal_emit_by_name", [
-        { type: { type: "gobject" }, value: getWidgetPtr(widget) },
+        { type: { type: "gobject" }, value: widget.ptr },
         { type: { type: "string" }, value: signalName },
     ], { type: "undefined" });
 };
@@ -10,10 +11,13 @@ const createUserEventInstance = (_options) => {
     return {
         click: async (element) => {
             emitSignal(element, "clicked");
+            await tick();
         },
         dblClick: async (element) => {
             emitSignal(element, "clicked");
+            await tick();
             emitSignal(element, "clicked");
+            await tick();
         },
         type: async (element, text) => {
             if (!hasSetText(element)) {
@@ -21,12 +25,14 @@ const createUserEventInstance = (_options) => {
             }
             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();
         },
     };
 };
@@ -34,10 +40,13 @@ export const userEvent = {
     setup: (options) => createUserEventInstance(options),
     click: async (element) => {
         emitSignal(element, "clicked");
+        await tick();
     },
     dblClick: async (element) => {
         emitSignal(element, "clicked");
+        await tick();
         emitSignal(element, "clicked");
+        await tick();
     },
     type: async (element, text) => {
         if (!hasSetText(element)) {
@@ -45,11 +54,13 @@ export const userEvent = {
         }
         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();
     },
 };

package/dist/widget.d.ts

@@ -1,5 +1,3 @@
-import type * as Gtk from "@gtkx/ffi/gtk";
-export declare const getWidgetPtr: (widget: Gtk.Widget) => unknown;
 type WidgetWithSetText = {
     setText: (text: string) => void;
 };

package/dist/widget.js

@@ -1,5 +1,2 @@
-export const getWidgetPtr = (widget) => {
-    return widget.ptr;
-};
 export const hasSetText = (widget) => typeof widget.setText === "function";
 export const hasGetText = (widget) => typeof widget.getText === "function";

package/package.json

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