@gtkx/testing 2.0.0-beta.5 → 2.0.0-beta.6

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/widget-accessible-properties.ts

@@ -401,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 =>
@@ -441,28 +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 = (target: Gtk.Accessible): boolean => {
-    const widget = requireWidget(target);
-    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,