@gtkx/testing 1.6.0 → 2.0.0-beta.10

package/src/widget-accessible-properties.ts

@@ -4,15 +4,16 @@ import {
     readAccessibleBooleanProperty,
     readAccessibleFlag,
     readAccessibleInt,
+    readAccessibleNumber,
     readAccessibleRelation,
     readAccessibleState,
-    readAccessibleNumber as readNativeNumber,
-    readAccessibleString as readNativeString,
+    readAccessibleString,
 } from "./accessible-native.js";
 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";
@@ -45,12 +46,6 @@ const VALUE_PROPERTIES: Record<WidgetValueField, Gtk.AccessibleProperty> = {
     max: Gtk.AccessibleProperty.VALUE_MAX,
 };
 
-const readAccessibleString = (widget: Gtk.Widget, property: Gtk.AccessibleProperty): string | null =>
-    readNativeString(widget, property);
-
-const readAccessibleNumber = (widget: Gtk.Widget, property: Gtk.AccessibleProperty): number | null =>
-    readNativeNumber(widget, property);
-
 const readAccessibleWidgets = (widget: Gtk.Widget, relation: Gtk.AccessibleRelation): Gtk.Widget[] | null => {
     const targets = readAccessibleRelation(widget, relation, relationCandidates(widget));
     const widgets = targets.filter((target): target is Gtk.Widget => target instanceof Gtk.Widget);
@@ -70,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);
 
@@ -93,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);
@@ -215,9 +210,7 @@ const getWidgetAccessibleName = (widget: Gtk.Widget): string | null => {
     return nameFromContent(widget) ?? callStringGetter(widget, "getTooltipText");
 };
 
-const getWidgetName = (widget: Gtk.Widget): string | null => {
-    return widget.getName();
-};
+const getWidgetName = (widget: Gtk.Widget): string | null => widget.getName();
 
 const nonEmptyText = (text: string | null): string | null => (text === null || text === "" ? null : text);
 
@@ -318,8 +311,6 @@ const readBoundedSelection = (widget: Gtk.Widget): string | null => {
 const getWidgetSelection = (widget: Gtk.Widget): string | null =>
     widget instanceof Gtk.TextView ? readTextViewSelection(widget) : readBoundedSelection(widget);
 
-const checkedFromActive = (isActive: boolean): CheckedState => (isActive ? "checked" : "unchecked");
-
 const isRadioToggle = (widget: Gtk.Widget): widget is Gtk.ToggleButton =>
     widget instanceof Gtk.ToggleButton && widget.getAccessibleRole() === Gtk.AccessibleRole.RADIO;
 
@@ -331,7 +322,11 @@ const getWidgetCheckedState = (widget: Gtk.Widget): CheckedState | null => {
         return state;
     }
 
-    return isRadioToggle(widget) ? checkedFromActive(widget.getActive()) : null;
+    if (!isRadioToggle(widget)) {
+        return null;
+    }
+
+    return widget.getActive() ? "checked" : "unchecked";
 };
 
 const isWidgetChecked = (widget: Gtk.Widget): boolean | null => {
@@ -368,26 +363,20 @@ const getWidgetSelectedState = (widget: Gtk.Widget): boolean | null => {
     return null;
 };
 
-const getWidgetLevel = (widget: Gtk.Widget): number | null => {
-    return readAccessibleInt(widget, Gtk.AccessibleProperty.LEVEL);
-};
-
-const getWidgetInvalidState = (widget: Gtk.Widget): Gtk.AccessibleInvalidState | null => {
-    const value = readAccessibleState(widget, Gtk.AccessibleState.INVALID);
+const getWidgetLevel = (widget: Gtk.Widget): number | null =>
+    readAccessibleInt(widget, Gtk.AccessibleProperty.LEVEL);
 
-    return value ?? null;
-};
+const getWidgetInvalidState = (widget: Gtk.Widget): Gtk.AccessibleInvalidState | null =>
+    readAccessibleState(widget, Gtk.AccessibleState.INVALID);
 
 const getWidgetErrorMessage = (widget: Gtk.Widget): Gtk.Widget[] | null =>
     readAccessibleWidgets(widget, Gtk.AccessibleRelation.ERROR_MESSAGE);
 
-const getWidgetBusyState = (widget: Gtk.Widget): boolean | null => {
-    return readAccessibleBoolean(widget, Gtk.AccessibleState.BUSY);
-};
+const getWidgetBusyState = (widget: Gtk.Widget): boolean | null =>
+    readAccessibleBoolean(widget, Gtk.AccessibleState.BUSY);
 
-const getWidgetDescription = (widget: Gtk.Widget): string | null => {
-    return readAccessibleString(widget, Gtk.AccessibleProperty.DESCRIPTION);
-};
+const getWidgetDescription = (widget: Gtk.Widget): string | null =>
+    readAccessibleString(widget, Gtk.AccessibleProperty.DESCRIPTION);
 
 const getWidgetValueNow = (widget: Gtk.Widget): number | null =>
     readAccessibleNumber(widget, Gtk.AccessibleProperty.VALUE_NOW);
@@ -398,23 +387,13 @@ const getWidgetValueText = (widget: Gtk.Widget): string | null =>
 const isWidgetValueMatch = (widget: Gtk.Widget, field: WidgetValueField, expected: number): boolean =>
     isAccessibleNumberMatch(widget, VALUE_PROPERTIES[field], expected);
 
-const getWidgetOwnLabel = (widget: Gtk.Widget): string | null => {
-    return readAccessibleString(widget, Gtk.AccessibleProperty.LABEL);
-};
+const getWidgetOwnLabel = (widget: Gtk.Widget): string | null =>
+    readAccessibleString(widget, Gtk.AccessibleProperty.LABEL);
 
-const collectAccessibleNames = (targets: Gtk.Widget[]): string[] => {
-    const texts: string[] = [];
-
-    for (const target of targets) {
-        const text = getWidgetAccessibleName(target);
-
-        if (text) {
-            texts.push(text);
-        }
-    }
-
-    return texts;
-};
+const collectAccessibleNames = (targets: Gtk.Widget[]): string[] =>
+    targets
+        .map((target) => getWidgetAccessibleName(target))
+        .filter((text): text is string => text !== null && text !== "");
 
 const isSelfLabelling = (widget: Gtk.Widget, targets: Gtk.Widget[]): boolean => {
     const own = new Set(descendants(widget));
@@ -422,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 =>
@@ -462,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 };