@gtkx/testing 2.0.0-beta.1 → 2.0.0-beta.10

package/src/user-event/index.ts

@@ -1,8 +1,19 @@
 import type * as Gtk from "@gtkx/gi/gtk";
 import { delay } from "../timers.js";
+import { requireWidget } from "../widget-target.js";
 import { scroll, slide } from "./adjustment.js";
 import { click, dblClick, tripleClick } from "./click.js";
-import { drag, dragAndDrop, drop, hover, longPress, rotate, swipe, unhover, zoom } from "./gesture.js";
+import {
+    drag,
+    dragAndDrop,
+    drop,
+    hover,
+    longPress,
+    rotate,
+    swipe,
+    unhover,
+    zoom,
+} from "./gesture.js";
 import { keyboard, tab } from "./keyboard.js";
 import { pointer, type PointerInput } from "./pointer.js";
 import { deselectOptions, selectOptions } from "./selection.js";
@@ -20,55 +31,126 @@ type UserEvent = {
     /** Creates an instance with shared keyboard and pointer state. */
     setup: (options?: UserEventOptions) => UserEvent;
     /** Activates or presses and releases a widget. */
-    click: typeof click;
+    click: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof click> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Delivers a double-click gesture. */
-    dblClick: typeof dblClick;
+    dblClick: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof dblClick> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Delivers a triple-click gesture. */
-    tripleClick: typeof tripleClick;
+    tripleClick: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof tripleClick> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Moves focus forward or backward within the root. */
-    tab: typeof tab;
+    tab: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof tab> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Types into an editable widget. */
-    type: typeof type;
+    type: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof type> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Deletes all text from an editable widget. */
-    clear: typeof clear;
+    clear: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof clear> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Copies the current selection. */
-    copy: typeof copy;
+    copy: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof copy> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Cuts the current selection. */
-    cut: typeof cut;
+    cut: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof cut> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Pastes text or clipboard contents. */
-    paste: typeof paste;
+    paste: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof paste> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Selects positions without activating them. */
     selectOptions: typeof selectOptions;
     /** Unselects positions without activating them. */
     deselectOptions: typeof deselectOptions;
     /** Emits a motion `enter` on the widget, adding a motion controller when it has none. */
-    hover: typeof hover;
+    hover: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof hover> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Emits a motion `leave` on the widget, adding a motion controller when it has none. */
-    unhover: typeof unhover;
+    unhover: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof unhover> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Emits `angle-changed` on the widget's rotate gestures. */
-    rotate: typeof rotate;
+    rotate: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof rotate> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Emits `scale-changed` on the widget's zoom gestures. */
-    zoom: typeof zoom;
+    zoom: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof zoom> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Emits `swipe` with the given velocity on the widget's swipe gestures. */
-    swipe: typeof swipe;
+    swipe: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof swipe> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Emits `pressed` at the given point on the widget's long-press gestures. */
-    longPress: typeof longPress;
+    longPress: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof longPress> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Runs a begin, update, and end sequence on the widget's drag gestures, ending at the given offset. */
-    drag: typeof drag;
+    drag: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof drag> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Emits `drop` with the given content on the widget's drop targets. */
-    drop: typeof drop;
+    drop: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof drop> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Requires a drag source on the source widget, then emits `drop` with the content on the target's drop targets. */
-    dragAndDrop: typeof dragAndDrop;
+    dragAndDrop: (
+        source: Gtk.Accessible,
+        target: Gtk.Accessible,
+        ...args: Parameters<typeof dragAndDrop> extends [Gtk.Widget, Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Emits a jump `change-value` on a Gtk.Range so it moves to the given value. */
-    slide: typeof slide;
+    slide: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof slide> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Adds the delta to the adjustments of the widget itself, or of its nearest scrollable ancestor. */
-    scroll: typeof scroll;
+    scroll: (
+        widget: Gtk.Accessible,
+        ...args: Parameters<typeof scroll> extends [Gtk.Widget, ...infer Args] ? Args : never
+    ) => Promise<void>;
     /** Sends a key sequence through GTK's propagation chain. */
-    keyboard: (widget: Gtk.Widget, input: string) => Promise<void>;
+    keyboard: (widget: Gtk.Accessible, input: string) => Promise<void>;
     /** Applies a pointer token while preserving held-button state. */
-    pointer: (widget: Gtk.Widget, input: PointerInput) => Promise<void>;
+    pointer: (widget: Gtk.Accessible, input: PointerInput) => Promise<void>;
 };
 
+const onWidget =
+    <Args extends unknown[]>(helper: (widget: Gtk.Widget, ...args: Args) => Promise<void>) =>
+        (target: Gtk.Accessible, ...args: Args): Promise<void> =>
+            helper(requireWidget(target), ...args);
+
+const onWidgetPair =
+    <Args extends unknown[]>(helper: (source: Gtk.Widget, target: Gtk.Widget, ...args: Args) => Promise<void>) =>
+        (source: Gtk.Accessible, target: Gtk.Accessible, ...args: Args): Promise<void> =>
+            helper(requireWidget(source), requireWidget(target), ...args);
+
 /** User interactions that dispatch GTK events and gestures. */
 const userEvent: UserEvent = {
     ...createInstance(createInitialState(), {}),
@@ -93,30 +175,34 @@ function createInstance(state: UserEventState, options: UserEventOptions): UserE
 
     return {
         setup: (overrides?: UserEventOptions): UserEvent => createInstance(state, { ...options, ...overrides }),
-        click: after(click),
-        dblClick: after(dblClick),
-        tripleClick: after(tripleClick),
-        tab: after(tab),
-        type: after(type),
-        clear: after(clear),
-        copy: after(copy),
-        cut: after(cut),
-        paste: after(paste),
-        selectOptions: after(selectOptions),
-        deselectOptions: after(deselectOptions),
-        hover: after(hover),
-        unhover: after(unhover),
-        rotate: after(rotate),
-        zoom: after(zoom),
-        swipe: after(swipe),
-        longPress: after(longPress),
-        drag: after(drag),
-        drop: after(drop),
-        dragAndDrop: after(dragAndDrop),
-        slide: after(slide),
-        scroll: after(scroll),
-        keyboard: after((widget: Gtk.Widget, input: string): Promise<void> => keyboard(state, widget, input)),
-        pointer: after((widget: Gtk.Widget, input: PointerInput): Promise<void> => pointer(state, widget, input)),
+        click: after(onWidget(click)),
+        dblClick: after(onWidget(dblClick)),
+        tripleClick: after(onWidget(tripleClick)),
+        tab: after(onWidget(tab)),
+        type: after(onWidget(type)),
+        clear: after(onWidget(clear)),
+        copy: after(onWidget(copy)),
+        cut: after(onWidget(cut)),
+        paste: after(onWidget(paste)),
+        selectOptions: after(onWidget(selectOptions)),
+        deselectOptions: after(onWidget(deselectOptions)),
+        hover: after(onWidget(hover)),
+        unhover: after(onWidget(unhover)),
+        rotate: after(onWidget(rotate)),
+        zoom: after(onWidget(zoom)),
+        swipe: after(onWidget(swipe)),
+        longPress: after(onWidget(longPress)),
+        drag: after(onWidget(drag)),
+        drop: after(onWidget(drop)),
+        dragAndDrop: after(onWidgetPair(dragAndDrop)),
+        slide: after(onWidget(slide)),
+        scroll: after(onWidget(scroll)),
+        keyboard: after(
+            onWidget((widget: Gtk.Widget, input: string): Promise<void> => keyboard(state, widget, input)),
+        ),
+        pointer: after(
+            onWidget((widget: Gtk.Widget, input: PointerInput): Promise<void> => pointer(state, widget, input)),
+        ),
     };
 }
 

package/src/user-event/keyboard.ts

@@ -18,6 +18,7 @@ type KeyAction = { keyval: number; isPress: boolean };
 type ParseStep = { actions: KeyAction[]; next: number };
 type KeyStopController = Gtk.EventControllerKey | Gtk.ShortcutController;
 type KeyStop = { widget: Gtk.Widget; controller: KeyStopController };
+type KeyTarget = { root: Gtk.Root | null; focus: Gtk.Widget | null };
 
 const KEY_MAP: Record<string, number> = {
     Enter: Gdk.KEY_Return,
@@ -366,9 +367,37 @@ const didStopHandlePress = (stop: KeyStop, keyval: number, modifiers: Gdk.Modifi
     return controller.emit("key-pressed", keyval, 0, modifiers);
 };
 
-const didHandlePress = (widget: Gtk.Widget, keyval: number, modifiers: Gdk.ModifierType): boolean =>
-    didDispatchApplicationAccels(widget, keyval, modifiers) ||
-    keyPropagationChain(widget).some((stop) => didStopHandlePress(stop, keyval, modifiers));
+const keyTargetFor = (widget: Gtk.Widget): KeyTarget => {
+    const root = widget.getRoot();
+
+    return { root, focus: root instanceof Gtk.Window ? root.getFocus() : null };
+};
+
+const isKeyTargetInvalidated = (widget: Gtk.Widget, target: KeyTarget): boolean => {
+    const current = keyTargetFor(widget);
+
+    return current.root !== target.root || current.focus !== target.focus || !widget.getMapped();
+};
+
+const didHandlePress = (widget: Gtk.Widget, keyval: number, modifiers: Gdk.ModifierType): boolean => {
+    const target = keyTargetFor(widget);
+
+    if (didDispatchApplicationAccels(widget, keyval, modifiers)) {
+        return true;
+    }
+
+    if (isKeyTargetInvalidated(widget, target)) {
+        return true;
+    }
+
+    for (const stop of keyPropagationChain(widget)) {
+        if (didStopHandlePress(stop, keyval, modifiers) || isKeyTargetInvalidated(widget, target)) {
+            return true;
+        }
+    }
+
+    return false;
+};
 
 const emitKeyReleased = (widget: Gtk.Widget, keyval: number, modifiers: Gdk.ModifierType): void => {
     for (const stop of keyPropagationChain(widget)) {

package/src/user-event/list-row-click.ts

@@ -1,5 +1,5 @@
-import type * as Gtk from "@gtkx/gi/gtk";
 import * as GLib from "@gtkx/gi/glib";
+import * as Gtk from "@gtkx/gi/gtk";
 import { ancestors } from "../traversal.js";
 import { callBooleanGetter, hasWidgetMethod } from "../widget-getters.js";
 
@@ -41,7 +41,7 @@ const applyRowPress = (row: Gtk.Widget, press: number): void => {
     selectRow(row);
 
     if (isRowActivatedByPress(row, press)) {
-        row.activate();
+        Gtk.Widget.prototype.activate.call(row);
     }
 };
 

package/src/user-event/pointer.ts

@@ -1,16 +1,15 @@
 import type * as Gtk from "@gtkx/gi/gtk";
-import type { NativeClick } from "./native-click.js";
 import type { UserEventState } from "./state.js";
-import { clickGestures, emitClickPhase, getAuthoredClickGestures } from "./click.js";
+import { type DirectClick, directClickFor, emitSitePhase } from "./click.js";
 import { wrapEvent } from "./event-wrapper.js";
-import { isClickTransparent, nativeClickFor } from "./native-click.js";
+import { isClickTransparent } from "./native-click.js";
 
 /**
  * A pointer action token: a full click (`click`, `[MouseLeft]`), a button press (`down`,
  * `[MouseLeft>]`), or a button release (`up`, `[/MouseLeft]`).
  */
 type PointerInput = "click" | "down" | "up" | "[MouseLeft]" | "[MouseLeft>]" | "[/MouseLeft]";
-type PointerTarget = { widget: Gtk.Widget; gestures: Gtk.GestureClick[]; native: NativeClick | null };
+type PointerTarget = { widget: Gtk.Widget; click: DirectClick };
 
 const PRESS_INPUTS: Set<PointerInput> = new Set(["[MouseLeft>]", "down"]);
 const RELEASE_INPUTS: Set<PointerInput> = new Set(["[/MouseLeft]", "up"]);
@@ -32,26 +31,23 @@ const pointerWidgetFor = (widget: Gtk.Widget): Gtk.Widget => {
     return current;
 };
 
-const pointerGesturesFor = (widget: Gtk.Widget, native: NativeClick | null): Gtk.GestureClick[] =>
-    native === null ? clickGestures(widget) : getAuthoredClickGestures(widget);
-
 const pointerTargetFor = (widget: Gtk.Widget): PointerTarget => {
     const target = pointerWidgetFor(widget);
-    const native = nativeClickFor(target, true);
 
-    return { widget: target, gestures: pointerGesturesFor(target, native), native };
+    return { widget: target, click: directClickFor(target) };
 };
 
-const pressPointer = ({ widget, gestures }: PointerTarget): void => {
-    emitClickPhase(widget, gestures, 1, "pressed");
+const pressPointer = ({ click }: PointerTarget): void => {
+    emitSitePhase(click.sites, 1, "pressed");
 };
 
-const releasePointer = ({ widget, gestures, native }: PointerTarget): void => {
-    emitClickPhase(widget, gestures, 1, "released");
-    native?.(widget, 1);
+const releasePointer = ({ widget, click }: PointerTarget): void => {
+    emitSitePhase(click.sites, 1, "released");
+    click.outcome?.(widget, 1);
 };
 
-const isPointerPressable = (target: PointerTarget): boolean => target.native !== null || target.gestures.length > 0;
+const isPointerPressable = (target: PointerTarget): boolean =>
+    target.click.outcome !== null || target.click.sites.some((site) => site.gestures.length > 0);
 
 const applyPointerInput = (widget: Gtk.Widget, state: UserEventState, input: PointerInput): void => {
     const target = pointerTargetFor(widget);

package/src/user-event/selection.ts

@@ -153,9 +153,17 @@ const runSelectionEvent = (
         byRole(widget, valueArray);
     });
 
+const requireWidget = (target: Gtk.Accessible): Gtk.Widget => {
+    if (!(target instanceof Gtk.Widget)) {
+        throw new TypeError("Cannot select options on a non-widget accessible");
+    }
+
+    return target;
+};
+
 /** Selects positions without activating them. */
-const selectOptions = (widget: Gtk.Widget, values: number | number[]): Promise<void> =>
-    runSelectionEvent(widget, values, selectInListView, selectByRole);
+const selectOptions = (widget: Gtk.Accessible, values: number | number[]): Promise<void> =>
+    runSelectionEvent(requireWidget(widget), values, selectInListView, selectByRole);
 
 const deselectInListView = (widget: Gtk.ListView | Gtk.GridView | Gtk.ColumnView, valueArray: number[]): void => {
     const selectionModel = requireSelectionModel(widget, "deselect");
@@ -176,7 +184,7 @@ const deselectByRole = (widget: Gtk.Widget, valueArray: number[]): void => {
 };
 
 /** Unselects positions without activating them. */
-const deselectOptions = (widget: Gtk.Widget, values: number | number[]): Promise<void> =>
-    runSelectionEvent(widget, values, deselectInListView, deselectByRole);
+const deselectOptions = (widget: Gtk.Accessible, values: number | number[]): Promise<void> =>
+    runSelectionEvent(requireWidget(widget), values, deselectInListView, deselectByRole);
 
 export { selectOptions, deselectOptions };

package/src/wait-for.ts

@@ -4,12 +4,13 @@ import { runWithActEnvironment } from "./act.js";
 import { getConfig } from "./config.js";
 import { timeoutError } from "./errors.js";
 import { advanceFakeClock, delay, now } from "./timers.js";
+import { requireWidget } from "./widget-target.js";
 
 type PollResult<T> = { status: "resolved"; value: T } | { status: "timedout"; lastError: Error | null };
 /** Widgets watched for removal; null counts as already removed. */
-type RemovalTarget = Gtk.Widget | Gtk.Widget[] | null;
+type RemovalTarget = Gtk.Accessible | Gtk.Accessible[] | null;
 /** The widgets to watch for removal, or a function re-read on every poll to locate them. */
-type ElementOrCallback = Gtk.Widget | Gtk.Widget[] | (() => RemovalTarget);
+type ElementOrCallback = Gtk.Accessible | Gtk.Accessible[] | (() => RemovalTarget);
 
 const DEFAULT_INTERVAL = 50;
 const ELEMENT_NOT_REMOVED = new Error("Element not yet removed");
@@ -102,10 +103,8 @@ const waitFor = <T>(callback: () => T | Promise<T>, options?: WaitForOptions): P
 const getTarget = (elementOrCallback: ElementOrCallback): RemovalTarget =>
     typeof elementOrCallback === "function" ? elementOrCallback() : elementOrCallback;
 
-const isWidgetRemoved = (widget: Gtk.Widget | null): boolean => {
-    if (widget === null) {
-        return true;
-    }
+const isWidgetRemoved = (target: Gtk.Accessible): boolean => {
+    const widget = requireWidget(target);
 
     try {
         return widget.getRoot() === null;
@@ -115,6 +114,10 @@ const isWidgetRemoved = (widget: Gtk.Widget | null): boolean => {
 };
 
 const isTargetRemoved = (target: RemovalTarget): boolean => {
+    if (target === null) {
+        return true;
+    }
+
     if (Array.isArray(target)) {
         return target.every((widget) => isWidgetRemoved(widget));
     }

package/src/widget-accessible-properties.ts

@@ -13,6 +13,7 @@ import { EDITABLE_ROLES, isEditable, readEditableText } from "./editable.js";
 import { isNameFromAuthor, isNameProhibited } from "./role-naming.js";
 import { children, descendants, relationCandidates } from "./traversal.js";
 import { callBooleanGetter, callStringGetter, getCallableMethod } from "./widget-getters.js";
+import { requireWidget } from "./widget-target.js";
 
 type WidgetValueField = "now" | "min" | "max";
 type CheckedState = "checked" | "unchecked" | "mixed";
@@ -64,12 +65,12 @@ const getLabelText = (widget: Gtk.Widget): string | null => {
 };
 
 const stripMnemonic = (text: string): string => text.replaceAll(/_(.)/g, "$1");
-const isUnderlineUsed = (widget: Gtk.Widget): boolean => callBooleanGetter(widget, "getUseUnderline") ?? false;
+const isUnderlineUsed = (widget: object): boolean => callBooleanGetter(widget, "getUseUnderline") ?? false;
 
-const readNamingText = (widget: Gtk.Widget, getter: string, value: string): string =>
+const readNamingText = (widget: object, getter: string, value: string): string =>
     getter !== EDITABLE_TEXT_GETTER && isUnderlineUsed(widget) ? stripMnemonic(value) : value;
 
-const readFirstText = (widget: Gtk.Widget, getters: string[]): string | null => {
+const readFirstText = (widget: object, getters: string[]): string | null => {
     for (const getter of getters) {
         const value = callStringGetter(widget, getter);
 
@@ -87,7 +88,7 @@ const readFirstText = (widget: Gtk.Widget, getters: string[]): string | null =>
  *
  * @param widget The widget to read text from.
  */
-const getWidgetText = (widget: Gtk.Widget): string | null => readFirstText(widget, DEFAULT_TEXT_GETTERS);
+const getWidgetText = (widget: Gtk.Accessible): string | null => readFirstText(widget, DEFAULT_TEXT_GETTERS);
 
 const namingLabelText = (widget: Gtk.Widget): string | null => {
     const text = getLabelText(widget);
@@ -400,22 +401,22 @@ const isSelfLabelling = (widget: Gtk.Widget, targets: Gtk.Widget[]): boolean =>
     return targets.every((target) => own.has(target));
 };
 
-const getWidgetLabelledByText = (widget: Gtk.Widget): string | null => {
-    const targets = readAccessibleWidgets(widget, Gtk.AccessibleRelation.LABELLED_BY);
-
-    if (targets === null) {
-        return null;
-    }
-
+const labelledByText = (targets: Gtk.Widget[]): string | null => {
     const texts = collectAccessibleNames(targets);
 
     return texts.length > 0 ? texts.join(" ") : null;
 };
 
+const getWidgetLabelledByText = (widget: Gtk.Widget): string | null => {
+    const targets = readAccessibleWidgets(widget, Gtk.AccessibleRelation.LABELLED_BY);
+
+    return targets === null ? null : labelledByText(targets);
+};
+
 const getWidgetExternalLabelText = (widget: Gtk.Widget): string | null => {
     const targets = readAccessibleWidgets(widget, Gtk.AccessibleRelation.LABELLED_BY);
 
-    return targets === null || isSelfLabelling(widget, targets) ? null : getWidgetLabelledByText(widget);
+    return targets === null || isSelfLabelling(widget, targets) ? null : labelledByText(targets);
 };
 
 const isTooltipUsedAsName = (widget: Gtk.Widget): boolean =>
@@ -440,27 +441,40 @@ const getWidgetDescribedByText = (widget: Gtk.Widget): string | null => {
     return isTooltipUsedAsName(widget) ? null : callStringGetter(widget, "getTooltipText");
 };
 
+const isHiddenWithin = (widget: Gtk.Widget, hiddenWidgets: Map<Gtk.Widget, boolean>): boolean => {
+    const cached = hiddenWidgets.get(widget);
+
+    if (cached !== undefined) {
+        return cached;
+    }
+
+    const parent = widget.getParent();
+
+    const isHidden =
+        readAccessibleBoolean(widget, Gtk.AccessibleState.HIDDEN) === true ||
+        (parent !== null && isHiddenWithin(parent, hiddenWidgets));
+
+    hiddenWidgets.set(widget, isHidden);
+
+    return isHidden;
+};
+
+const buildInaccessibilityCheck = (): ((target: Gtk.Accessible) => boolean) => {
+    const hiddenWidgets: Map<Gtk.Widget, boolean> = new Map();
+
+    return (target) => isHiddenWithin(requireWidget(target), hiddenWidgets);
+};
+
 /**
  * Returns whether a widget is excluded from the accessibility tree, because it or one of its
  * ancestors is marked hidden.
  *
  * @param widget The widget to test.
  */
-const isInaccessible = (widget: Gtk.Widget): boolean => {
-    let current: Gtk.Widget | null = widget;
-
-    while (current) {
-        if (readAccessibleBoolean(current, Gtk.AccessibleState.HIDDEN) === true) {
-            return true;
-        }
-
-        current = current.getParent();
-    }
-
-    return false;
-};
+const isInaccessible = (target: Gtk.Accessible): boolean => buildInaccessibilityCheck()(target);
 
 export {
+    buildInaccessibilityCheck,
     namingLabelText,
     getWidgetText,
     getWidgetTextContent,

package/src/widget-getters.ts

@@ -1,28 +1,26 @@
-import type * as GObject from "@gtkx/gi/gobject";
-import type * as Gtk from "@gtkx/gi/gtk";
 import { getClassType, getInstanceType, TYPE_INVALID, typeName } from "@gtkx/runtime";
 import { resolveWrapperClass } from "@gtkx/runtime/internal";
 import { type AnyClass, walkClassChain } from "@gtkx/utils";
 
 const UNNAMED_TYPE_TAG = "Object";
 
-const getWidgetMethod = (widget: Gtk.Widget, name: string): unknown => Reflect.get(widget, name);
-const getWidgetTypeName = (widget: Gtk.Widget): string | null => typeName(getInstanceType(widget));
+const getWidgetMethod = (widget: object, name: string): unknown => Reflect.get(widget, name);
+const getWidgetTypeName = (widget: object): string | null => typeName(getInstanceType(widget));
 const isClass = (value: unknown): value is AnyClass => typeof value === "function";
 
 const nonEmpty = (value: unknown): string | undefined =>
     typeof value === "string" && value.length > 0 ? value : undefined;
 
-const getObjectClass = (object: GObject.Object): AnyClass | null => {
+const getObjectClass = (object: object): AnyClass | null => {
     const cls: unknown = object.constructor;
 
     return isClass(cls) ? cls : null;
 };
 
-const getNearestClassName = (object: GObject.Object): string | undefined =>
+const getNearestClassName = (object: object): string | undefined =>
     walkClassChain(getObjectClass(object), (ancestor) => nonEmpty(ancestor.name));
 
-const getUntypedClassName = (object: GObject.Object): string | undefined => {
+const getUntypedClassName = (object: object): string | undefined => {
     const cls = getObjectClass(object);
 
     return cls !== null && getClassType(cls) === TYPE_INVALID ? nonEmpty(cls.name) : undefined;
@@ -34,7 +32,7 @@ const getExactWrapperName = (type: bigint): string | undefined => {
     return wrapper !== null && getClassType(wrapper) === type ? nonEmpty(wrapper.name) : undefined;
 };
 
-const getTypeTag = (object: GObject.Object): string => {
+const getTypeTag = (object: object): string => {
     const type = getInstanceType(object);
 
     return (
@@ -46,15 +44,15 @@ const getTypeTag = (object: GObject.Object): string => {
     );
 };
 
-const isDefaultWidgetName = (widget: Gtk.Widget, name: string): boolean =>
+const isDefaultWidgetName = (widget: object, name: string): boolean =>
     name.length === 0 || name === getWidgetTypeName(widget);
 
-const hasWidgetMethod = (widget: Gtk.Widget, name: string): boolean =>
+const hasWidgetMethod = (widget: object, name: string): boolean =>
     typeof getWidgetMethod(widget, name) === "function";
 
 /* eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- callers name the signature */
 const getCallableMethod = <Args extends unknown[], Result>(
-    widget: Gtk.Widget,
+    widget: object,
     name: string,
 ): ((...args: Args) => Result) | null => {
     const fn = getWidgetMethod(widget, name);
@@ -62,13 +60,13 @@ const getCallableMethod = <Args extends unknown[], Result>(
     return typeof fn === "function" ? (fn as (...args: Args) => Result).bind(widget) : null;
 };
 
-const callBooleanGetter = (widget: Gtk.Widget, method: string): boolean | null => {
+const callBooleanGetter = (widget: object, method: string): boolean | null => {
     const value = getCallableMethod<[], unknown>(widget, method)?.();
 
     return typeof value === "boolean" ? value : null;
 };
 
-const callStringGetter = (widget: Gtk.Widget, method: string): string | null => {
+const callStringGetter = (widget: object, method: string): string | null => {
     const value = getCallableMethod<[], unknown>(widget, method)?.();
 
     return typeof value === "string" ? value : null;

package/src/widget-target.ts

@@ -0,0 +1,11 @@
+import * as Gtk from "@gtkx/gi/gtk";
+
+const requireWidget = (target: object): Gtk.Widget => {
+    if (!(target instanceof Gtk.Widget)) {
+        throw new TypeError("Expected a Gtk.Widget");
+    }
+
+    return target;
+};
+
+export { requireWidget };