@gtkx/testing 0.21.0 → 1.0.0-rc.1

package/src/build-queries.ts

@@ -0,0 +1,185 @@
+import type * as Gtk from "@gtkx/gi/gtk";
+import { getConfig } from "./config.js";
+import { runWithExpensiveErrorDiagnosticsDisabled, suggestionError } from "./errors.js";
+import { getSuggestedQuery, type Method, type Variant } from "./suggestions.js";
+import type { Container } from "./traversal.js";
+import type { MatcherOptions, WaitForOptions } from "./types.js";
+import { waitFor } from "./wait-for.js";
+
+export type QueryAllBy<Args extends unknown[]> = (container: Container, ...args: Args) => Gtk.Widget[];
+
+type MultipleErrorBuilder<Args extends unknown[]> = (
+    container: Container,
+    matches: Gtk.Widget[],
+    ...args: Args
+) => Error;
+type MissingErrorBuilder<Args extends unknown[]> = (container: Container, ...args: Args) => Error;
+
+export type BuiltQueries<Args extends unknown[]> = {
+    queryBy: (container: Container, ...args: Args) => Gtk.Widget | null;
+    getAllBy: QueryAllBy<Args>;
+    getBy: (container: Container, ...args: Args) => Gtk.Widget;
+    findAllBy: (container: Container, ...args: Args) => Promise<Gtk.Widget[]>;
+    findBy: (container: Container, ...args: Args) => Promise<Gtk.Widget>;
+};
+
+const extractWaitForOptions = (args: unknown[]): WaitForOptions => {
+    const last = args[args.length - 1];
+    if (last && typeof last === "object" && !(last instanceof RegExp)) {
+        const { timeout, interval, onTimeout } = last as WaitForOptions;
+        return { timeout, interval, onTimeout };
+    }
+    return {};
+};
+
+const extractSuggestOption = (args: unknown[]): boolean | undefined => {
+    const last = args[args.length - 1];
+    if (last && typeof last === "object" && !(last instanceof RegExp)) {
+        return (last as MatcherOptions).suggest;
+    }
+    return undefined;
+};
+
+const maybeThrowSuggestion = (options: {
+    container: Container;
+    match: Gtk.Widget;
+    queryName: Method;
+    variant: Variant;
+    suggest: boolean | undefined;
+}): void => {
+    const { container, match, queryName, variant, suggest } = options;
+    const shouldSuggest = suggest ?? getConfig().throwSuggestions;
+    if (!shouldSuggest) return;
+
+    const suggestion = getSuggestedQuery(match, variant);
+    if (suggestion && suggestion.queryName !== queryName) {
+        throw suggestionError(suggestion.toString(), container);
+    }
+};
+
+type FindQuery<Args extends unknown[]> = (container: Container, ...args: Args) => unknown;
+
+const reRunForDiagnostics = <Args extends unknown[]>(
+    query: FindQuery<Args>,
+    container: Container,
+    args: Args,
+    fallback: Error,
+): Error => {
+    try {
+        query(container, ...args);
+    } catch (error) {
+        if (error instanceof Error) return error;
+    }
+    return fallback;
+};
+
+const findOptions = <Args extends unknown[]>(
+    query: FindQuery<Args>,
+    container: Container,
+    args: Args,
+): WaitForOptions => {
+    const userOptions = extractWaitForOptions(args);
+    const onTimeout =
+        userOptions.onTimeout ?? ((fallback: Error) => reRunForDiagnostics(query, container, args, fallback));
+    return {
+        stackTraceError: new Error("STACK_TRACE_MESSAGE"),
+        onTimeout,
+        timeout: userOptions.timeout,
+        interval: userOptions.interval,
+    };
+};
+
+type SingleQuery<Args extends unknown[]> = (container: Container, ...args: Args) => Gtk.Widget | null;
+
+const singleFrom =
+    <Args extends unknown[]>(
+        allQuery: QueryAllBy<Args>,
+        getMultipleError: MultipleErrorBuilder<Args>,
+    ): SingleQuery<Args> =>
+    (container, ...args) => {
+        const matches = allQuery(container, ...args);
+        if (matches.length > 1) throw getMultipleError(container, matches, ...args);
+        return matches[0] ?? null;
+    };
+
+const allOrThrow =
+    <Args extends unknown[]>(
+        allQuery: QueryAllBy<Args>,
+        getMissingError: MissingErrorBuilder<Args>,
+    ): QueryAllBy<Args> =>
+    (container, ...args) => {
+        const matches = allQuery(container, ...args);
+        if (matches.length === 0) throw getMissingError(container, ...args);
+        return matches;
+    };
+
+const wrapSingleWithSuggestion =
+    <Args extends unknown[]>(query: SingleQuery<Args>, queryName: Method, variant: Variant): SingleQuery<Args> =>
+    (container, ...args) => {
+        const match = query(container, ...args);
+        if (match) {
+            maybeThrowSuggestion({ container, match, queryName, variant, suggest: extractSuggestOption(args) });
+        }
+        return match;
+    };
+
+const wrapAllWithSuggestion =
+    <Args extends unknown[]>(query: QueryAllBy<Args>, queryName: Method, variant: Variant): QueryAllBy<Args> =>
+    (container, ...args) => {
+        const matches = query(container, ...args);
+        const [first] = matches;
+        if (first !== undefined) {
+            maybeThrowSuggestion({ container, match: first, queryName, variant, suggest: extractSuggestOption(args) });
+        }
+        return matches;
+    };
+
+const requireSingle =
+    <Args extends unknown[]>(query: SingleQuery<Args>, getMissingError: MissingErrorBuilder<Args>) =>
+    (container: Container, ...args: Args): Gtk.Widget => {
+        const match = query(container, ...args);
+        if (match === null) throw getMissingError(container, ...args);
+        return match;
+    };
+
+export const buildQueries = <Args extends unknown[]>(
+    queryName: Method,
+    queryAllBy: QueryAllBy<Args>,
+    getMultipleError: MultipleErrorBuilder<Args>,
+    getMissingError: MissingErrorBuilder<Args>,
+): BuiltQueries<Args> => {
+    const getAllBy = allOrThrow(queryAllBy, getMissingError);
+    const getBy = requireSingle(singleFrom(getAllBy, getMultipleError), getMissingError);
+
+    const queryByWithSuggestion = wrapSingleWithSuggestion(
+        singleFrom(queryAllBy, getMultipleError),
+        queryName,
+        "query",
+    );
+    const getAllByWithSuggestion = wrapAllWithSuggestion(getAllBy, queryName, "getAll");
+    const getByWithSuggestion: (container: Container, ...args: Args) => Gtk.Widget = (container, ...args) => {
+        const match = getBy(container, ...args);
+        maybeThrowSuggestion({ container, match, queryName, variant: "get", suggest: extractSuggestOption(args) });
+        return match;
+    };
+
+    const findAllBy = (container: Container, ...args: Args): Promise<Gtk.Widget[]> =>
+        waitFor(
+            () => runWithExpensiveErrorDiagnosticsDisabled(() => getAllByWithSuggestion(container, ...args)),
+            findOptions(getAllByWithSuggestion, container, args),
+        );
+
+    const findBy = (container: Container, ...args: Args): Promise<Gtk.Widget> =>
+        waitFor(
+            () => runWithExpensiveErrorDiagnosticsDisabled(() => getByWithSuggestion(container, ...args)),
+            findOptions(getByWithSuggestion, container, args),
+        );
+
+    return {
+        queryBy: queryByWithSuggestion,
+        getAllBy: getAllByWithSuggestion,
+        getBy: getByWithSuggestion,
+        findAllBy,
+        findBy,
+    };
+};

package/src/cleanup-registry.ts

@@ -0,0 +1,14 @@
+export type CleanupFunction = () => void | Promise<void>;
+
+const cleanupQueue = new Set<CleanupFunction>();
+
+export const addToCleanupQueue = (fn: CleanupFunction): void => {
+    cleanupQueue.add(fn);
+};
+
+export const runCleanup = async (): Promise<void> => {
+    for (const fn of cleanupQueue) {
+        await fn();
+    }
+    cleanupQueue.clear();
+};

package/src/config.ts

@@ -1,89 +1,58 @@
 import type { Container } from "./traversal.js";
 
 /**
- * Configuration options for the testing library.
+ * Global configuration for the testing harness, controlling query behavior,
+ * error formatting, and the timeouts used by async utilities and actionability
+ * checks.
  */
 export type Config = {
-    /**
-     * Whether to show role suggestions in error messages when elements are not found.
-     * @default true
-     */
-    showSuggestions: boolean;
+    throwSuggestions: boolean;
 
-    /**
-     * Custom error factory for query failures.
-     * Allows customizing how errors are constructed.
-     */
-    getElementError: (message: string, container: Container) => Error;
+    /** Builds the error thrown when a query fails, given a message and optional container. */
+    getElementError: (message: string, container?: Container) => Error;
 
-    /**
-     * Default timeout in milliseconds for async utilities (waitFor, findBy* queries).
-     * @default 1000
-     */
+    /** Default timeout in milliseconds for async utilities such as waitFor. */
     asyncUtilTimeout: number;
+
+    /** Timeout in milliseconds for waiting on a widget to become actionable. */
+    actionabilityTimeout: number;
 };
 
-const defaultGetElementError = (message: string, _container: Container): Error => {
-    return new Error(message);
+/**
+ * Function form of a configuration update: receives the current config and
+ * returns the fields to override.
+ */
+export type ConfigFn = (existingConfig: Config) => Partial<Config>;
+
+const defaultGetElementError = (message: string, _container?: Container): Error => {
+    const error = new Error(message);
+    error.name = "GtkxElementError";
+    return error;
 };
 
 const defaultConfig: Config = {
-    showSuggestions: true,
+    throwSuggestions: false,
     getElementError: defaultGetElementError,
     asyncUtilTimeout: 1000,
+    actionabilityTimeout: 500,
 };
 
 let currentConfig: Config = { ...defaultConfig };
 
 /**
- * Returns the current testing library configuration.
- *
- * @returns The current configuration object
- *
- * @example
- * ```tsx
- * import { getConfig } from "@gtkx/testing";
- *
- * const config = getConfig();
- * console.log(config.showSuggestions);
- * ```
+ * Returns the current global testing configuration.
  */
-export const getConfig = (): Readonly<Config> => {
+export const getConfig = (): Config => {
     return currentConfig;
 };
 
 /**
- * Configures the testing library behavior.
- *
- * Accepts either a partial configuration object or a function that receives
- * the current configuration and returns updates.
+ * Merges the given overrides into the global testing configuration.
  *
- * @param newConfig - Partial configuration or updater function
- *
- * @example
- * ```tsx
- * import { configure } from "@gtkx/testing";
- *
- * // Disable role suggestions
- * configure({ showSuggestions: false });
- *
- * // Use updater function
- * configure((current) => ({
- *   showSuggestions: !current.showSuggestions,
- * }));
- * ```
+ * @param newConfig Either a partial config object or a function that receives
+ * the current config and returns the fields to override.
  */
-export const configure = (newConfig: Partial<Config> | ((current: Config) => Partial<Config>)): void => {
+export const configure = (newConfig: Partial<Config> | ConfigFn): void => {
     const updates = typeof newConfig === "function" ? newConfig(currentConfig) : newConfig;
     currentConfig = { ...currentConfig, ...updates };
 };
-
-/**
- * Resets configuration to defaults.
- * Primarily used for testing.
- *
- * @internal
- */
-export const resetConfig = (): void => {
-    currentConfig = { ...defaultConfig };
-};

package/src/editable.ts

@@ -0,0 +1,30 @@
+import * as Gtk from "@gtkx/gi/gtk";
+
+export type EditableTarget = Gtk.Editable | Gtk.TextView;
+
+export const EDITABLE_ROLES: Set<Gtk.AccessibleRole> = new Set<Gtk.AccessibleRole>([
+    Gtk.AccessibleRole.TEXT_BOX,
+    Gtk.AccessibleRole.SEARCH_BOX,
+    Gtk.AccessibleRole.SPIN_BUTTON,
+]);
+
+export const isEditable = (widget: unknown): widget is EditableTarget =>
+    widget instanceof Gtk.Editable || widget instanceof Gtk.TextView;
+
+export const getEditableDelegate = (widget: Gtk.Widget): Gtk.Widget | null => {
+    if (!(widget instanceof Gtk.Editable)) return null;
+    return widget.getDelegate();
+};
+
+const readTextViewBufferText = (widget: Gtk.TextView): string => {
+    const buffer = widget.getBuffer();
+    const [start, end] = buffer.getBounds();
+    return buffer.getText(start, end, true);
+};
+
+export const readEditableText = (widget: EditableTarget): string => {
+    if (widget instanceof Gtk.TextView) {
+        return readTextViewBufferText(widget);
+    }
+    return widget.getText();
+};

package/src/errors.ts

@@ -0,0 +1,130 @@
+import type * as Gtk from "@gtkx/gi/gtk";
+import { getConfig } from "./config.js";
+import { prettyWidget } from "./pretty-widget.js";
+import { formatRole, prettyRoles } from "./role-helpers.js";
+import type { Container } from "./traversal.js";
+import type { ByRoleOptions, ByRoleValue, Matcher } from "./types.js";
+
+const formatTextMatcher = (text: Matcher): string => {
+    if (typeof text === "function") {
+        return "custom function";
+    }
+    if (text instanceof RegExp) {
+        return text.toString();
+    }
+    return `'${text}'`;
+};
+
+const formatByRoleValue = (value: ByRoleValue): string => {
+    const parts: string[] = [];
+    if (value.now !== undefined) parts.push(`now=${value.now}`);
+    if (value.min !== undefined) parts.push(`min=${value.min}`);
+    if (value.max !== undefined) parts.push(`max=${value.max}`);
+    if (value.text !== undefined) parts.push(`text ${formatTextMatcher(value.text)}`);
+    return parts.join(", ");
+};
+
+const formatByRoleDescription = (role: Gtk.AccessibleRole, options?: ByRoleOptions): string => {
+    const parts = [`role '${formatRole(role).toUpperCase()}'`];
+    if (options?.name) parts.push(`name ${formatTextMatcher(options.name)}`);
+    if (options?.checked !== undefined) parts.push(`checked=${options.checked}`);
+    if (options?.pressed !== undefined) parts.push(`pressed=${options.pressed}`);
+    if (options?.selected !== undefined) parts.push(`selected=${options.selected}`);
+    if (options?.expanded !== undefined) parts.push(`expanded=${options.expanded}`);
+    if (options?.level !== undefined) parts.push(`level=${options.level}`);
+    if (options?.busy !== undefined) parts.push(`busy=${options.busy}`);
+    if (options?.description) parts.push(`description ${formatTextMatcher(options.description)}`);
+    if (options?.value) parts.push(`value ${formatByRoleValue(options.value)}`);
+    if (options?.hidden !== undefined) parts.push(`hidden=${options.hidden}`);
+    return parts.join(" and ");
+};
+
+export type QueryDescriptor =
+    | { queryType: "role"; role: Gtk.AccessibleRole; options?: ByRoleOptions | undefined }
+    | { queryType: "text"; text: Matcher }
+    | { queryType: "labelText"; text: Matcher }
+    | { queryType: "name"; name: Matcher }
+    | { queryType: "placeholderText"; text: Matcher }
+    | { queryType: "displayValue"; value: Matcher };
+
+const formatQueryDescription = (descriptor: QueryDescriptor): string => {
+    switch (descriptor.queryType) {
+        case "role":
+            return formatByRoleDescription(descriptor.role, descriptor.options);
+        case "text":
+            return `text ${formatTextMatcher(descriptor.text)}`;
+        case "labelText":
+            return `label text ${formatTextMatcher(descriptor.text)}`;
+        case "name":
+            return `name ${formatTextMatcher(descriptor.name)}`;
+        case "placeholderText":
+            return `placeholder text ${formatTextMatcher(descriptor.text)}`;
+        case "displayValue":
+            return `display value ${formatTextMatcher(descriptor.value)}`;
+    }
+};
+
+let expensiveErrorDiagnosticsDisabled = false;
+
+export const runWithExpensiveErrorDiagnosticsDisabled = <T>(callback: () => T): T => {
+    const previous = expensiveErrorDiagnosticsDisabled;
+    expensiveErrorDiagnosticsDisabled = true;
+    try {
+        return callback();
+    } finally {
+        expensiveErrorDiagnosticsDisabled = previous;
+    }
+};
+
+const buildElementError = (container: Container, headLines: string[]): Error => {
+    const config = getConfig();
+    const lines = expensiveErrorDiagnosticsDisabled
+        ? headLines
+        : [...headLines, "", prettyWidget(container, { highlight: false })];
+    return config.getElementError(lines.join("\n"), container);
+};
+
+export const notFoundError = (container: Container, descriptor: QueryDescriptor): Error => {
+    const description = formatQueryDescription(descriptor);
+    const headLines = [`Unable to find an element with ${description}`];
+
+    if (!expensiveErrorDiagnosticsDisabled && descriptor.queryType === "role") {
+        headLines.push("", "Here are the accessible roles:", "", prettyRoles(container));
+    }
+
+    return buildElementError(container, headLines);
+};
+
+const allByVariantHint = (descriptor: QueryDescriptor): string => {
+    const variant = descriptor.queryType === "role" ? "getAllByRole" : "getAllBy*";
+    return (
+        "(If this is intentional, use the *AllBy* variant of the query, " +
+        `e.g. queryAllBy*/getAllBy*/findAllBy*, such as ${variant}.)`
+    );
+};
+
+export const multipleFoundError = (container: Container, descriptor: QueryDescriptor, matches: Gtk.Widget[]): Error => {
+    const description = formatQueryDescription(descriptor);
+    const headLines = [
+        `Found ${matches.length} elements with ${description}, but expected only one`,
+        "",
+        allByVariantHint(descriptor),
+    ];
+    if (!expensiveErrorDiagnosticsDisabled) {
+        const renderedMatches = matches.map((widget) => prettyWidget(widget, { highlight: false }));
+        headLines.push("", "Here are the matching elements:", "", ...renderedMatches);
+    }
+    return buildElementError(container, headLines);
+};
+
+export const suggestionError = (suggestion: string, container: Container): Error => {
+    const config = getConfig();
+    const message = `A better query is available, try this:\n${suggestion}\n`;
+    return config.getElementError(message, container);
+};
+
+export const timeoutError = (timeout: number, lastError: Error | null): Error => {
+    const baseMessage = `Timed out after ${timeout}ms`;
+    const message = lastError ? `${baseMessage}.\n\n${lastError.message}` : baseMessage;
+    return getConfig().getElementError(message);
+};

package/src/fire-event.ts

@@ -1,43 +1,16 @@
-import { type Object as GObject, signalEmitv, signalLookup, typeFromName, Value } from "@gtkx/ffi/gobject";
-import type * as Gtk from "@gtkx/ffi/gtk";
-import { tick } from "./timing.js";
+import type * as GObject from "@gtkx/gi/gobject";
+import { runInAct } from "./act.js";
 
 /**
- * Emits a GTK signal on a widget or event controller.
+ * Emits a GObject signal on a widget or object inside React's act environment,
+ * so any resulting state updates are flushed before the promise resolves.
  *
- * Low-level utility for triggering signals directly. Prefer {@link userEvent}
- * for common interactions like clicking and typing.
- *
- * @param element - The widget or event controller to emit the signal on
- * @param signalName - GTK signal name (e.g., "clicked", "activate", "drag-begin")
- * @param args - Additional signal arguments as GValues
- *
- * @example
- * ```tsx
- * import { fireEvent } from "@gtkx/testing";
- * import { Value } from "@gtkx/ffi/gobject";
- *
- * // Emit signal on widget
- * await fireEvent(widget, "clicked");
- *
- * // Emit signal on gesture controller
- * const gesture = widget.observeControllers().getObject(0) as Gtk.GestureDrag;
- * await fireEvent(gesture, "drag-begin", Value.newFromDouble(100), Value.newFromDouble(100));
- * ```
- *
- * @see {@link userEvent} for high-level user interactions
+ * @param element The GObject instance to emit the signal on.
+ * @param signalName Name of the signal to emit.
+ * @param args Arguments passed to the signal handlers.
  */
-export const fireEvent = async (
-    element: Gtk.Widget | Gtk.EventController,
-    signalName: string,
-    ...args: Value[]
-): Promise<void> => {
-    const gtype = typeFromName((element.constructor as typeof GObject).glibTypeName);
-    const signalId = signalLookup(signalName, gtype);
-
-    const instanceValue = Value.newFromObject(element as GObject);
-
-    signalEmitv([instanceValue, ...args], signalId, 0);
-
-    await tick();
+export const fireEvent = async (element: GObject.Object, signalName: string, ...args: unknown[]): Promise<void> => {
+    await runInAct(() => {
+        element.emit(signalName, ...args);
+    });
 };

package/src/frame-sync.ts

@@ -0,0 +1,34 @@
+import type * as Gtk from "@gtkx/gi/gtk";
+
+const CLOCK_STALL_FALLBACK_MS = 500;
+
+export const scheduleAfterLayout = (widget: Gtk.Widget | null, callback: () => void): void => {
+    let done = false;
+    let removeTick: (() => void) | null = null;
+    let fallback: ReturnType<typeof setTimeout> | null = null;
+
+    const finish = (): void => {
+        if (done) return;
+        done = true;
+        if (fallback !== null) clearTimeout(fallback);
+        removeTick?.();
+        removeTick = null;
+        fallback = null;
+        callback();
+    };
+
+    if (widget === null || widget.getFrameClock() === null || widget.getWidth() > 0) {
+        queueMicrotask(finish);
+        return;
+    }
+
+    fallback = setTimeout(finish, CLOCK_STALL_FALLBACK_MS);
+
+    const tickId = widget.addTickCallback(() => {
+        if (widget.getWidth() === 0) return true;
+        finish();
+        return false;
+    });
+
+    removeTick = () => widget.removeTickCallback(tickId);
+};

package/src/index.ts

@@ -1,51 +1,93 @@
-export type { Config } from "./config.js";
+import "./register-test-hooks.js";
+
+export { act } from "./act.js";
+export type { BoundQueries, RenderResult, Screen } from "./bound-queries.js";
+export type { Config, ConfigFn } from "./config.js";
 export { configure, getConfig } from "./config.js";
 export { fireEvent } from "./fire-event.js";
+export type { TextExpectation } from "./matchers.js";
+export { matchers, registerMatchers } from "./matchers.js";
 export type { PrettyWidgetOptions } from "./pretty-widget.js";
-export { prettyWidget } from "./pretty-widget.js";
+export { logWidget, prettyWidget } from "./pretty-widget.js";
 export {
+    findAllByDisplayValue,
     findAllByLabelText,
     findAllByName,
+    findAllByPlaceholderText,
     findAllByRole,
     findAllByText,
+    findByDisplayValue,
     findByLabelText,
     findByName,
+    findByPlaceholderText,
     findByRole,
     findByText,
+    getAllByDisplayValue,
+    getAllByLabelText,
+    getAllByName,
+    getAllByPlaceholderText,
+    getAllByRole,
+    getAllByText,
+    getByDisplayValue,
+    getByLabelText,
+    getByName,
+    getByPlaceholderText,
+    getByRole,
+    getByText,
+    getDefaultNormalizer,
+    queryAllByDisplayValue,
     queryAllByLabelText,
     queryAllByName,
+    queryAllByPlaceholderText,
     queryAllByRole,
     queryAllByText,
+    queryByDisplayValue,
     queryByLabelText,
     queryByName,
+    queryByPlaceholderText,
     queryByRole,
     queryByText,
 } from "./queries.js";
 export { cleanup, render } from "./render.js";
 export { renderHook } from "./render-hook.js";
-export type { RoleInfo } from "./role-helpers.js";
-export { getRoles, logRoles, prettyRoles } from "./role-helpers.js";
+export { formatRole, getRoles, logRoles, prettyRoles } from "./role-helpers.js";
 export { screen } from "./screen.js";
-export type { ScreenshotOptions } from "./screenshot.js";
-export { screenshot } from "./screenshot.js";
-export { tick } from "./timing.js";
+export { captureAndSaveScreenshot, logScreenshotPath, screenshot } from "./screenshot.js";
+export type { Method, Suggestion, Variant } from "./suggestions.js";
+export { getSuggestedQuery } from "./suggestions.js";
 export type { Container } from "./traversal.js";
 export type {
-    BoundQueries,
     ByRoleOptions,
+    ByRoleValue,
+    Matcher,
+    MatcherFunction,
+    MatcherOptions,
+    NormalizerFn,
     NormalizerOptions,
     RenderHookOptions,
     RenderHookResult,
     RenderOptions,
-    RenderResult,
+    ScreenshotOptions,
     ScreenshotResult,
-    TextMatch,
-    TextMatchFunction,
-    TextMatchOptions,
     WaitForOptions,
+    WindowSelector,
     WrapperComponent,
 } from "./types.js";
-export type { PointerInput, TabOptions } from "./user-event.js";
-export { userEvent } from "./user-event.js";
+export type {
+    DragOffset,
+    DragOptions,
+    DropContent,
+    DropOptions,
+    PointerInput,
+    TabOptions,
+    TypeOptions,
+    UserEvent,
+} from "./user-event/index.js";
+export { userEvent } from "./user-event/index.js";
 export { waitFor, waitForElementToBeRemoved } from "./wait-for.js";
+export {
+    getWidgetErrorMessage,
+    getWidgetInvalidState,
+    getWidgetNodeText,
+} from "./widget-accessible-properties.js";
 export { within } from "./within.js";