@gtkx/testing 1.0.0-rc.3 → 1.0.0

package/src/widget-accessible-properties.ts

@@ -1,20 +1,24 @@
 import * as Gtk from "@gtkx/gi/gtk";
-import { getAccessibleMetadata } from "@gtkx/react/internal";
+import {
+    isAccessibleNumberMatch,
+    readAccessibleBooleanProperty,
+    readAccessibleFlag,
+    readAccessibleInt,
+    readAccessibleRelation,
+    readAccessibleState,
+    readAccessibleNumber as readNativeNumber,
+    readAccessibleString as readNativeString,
+} from "./accessible-native.js";
 import { EDITABLE_ROLES, isEditable, readEditableText } from "./editable.js";
-import { descendants } from "./traversal.js";
+import { isNameFromAuthor, isNameProhibited } from "./role-naming.js";
+import { children, descendants, relationCandidates } from "./traversal.js";
+import { callBooleanGetter, callStringGetter, getCallableMethod } from "./widget-getters.js";
 
-type WidgetValue = {
-    now: number | null;
-    min: number | null;
-    max: number | null;
-    text: string | null;
-};
-
-type ValueTriplet = { now: number | null; min: number | null; max: number | null };
-/** A widget's checked state: on, off, or the mixed state of an inconsistent check button. */
+type WidgetValueField = "now" | "min" | "max";
 type CheckedState = "checked" | "unchecked" | "mixed";
 
-const DEFAULT_TEXT_GETTERS = ["getLabel", "getText", "getTitle"] as const;
+const EDITABLE_TEXT_GETTER = "getText";
+const DEFAULT_TEXT_GETTERS = ["getLabel", EDITABLE_TEXT_GETTER, "getTitle"];
 
 const SELECTABLE_ROLES: Set<Gtk.AccessibleRole> = new Set<Gtk.AccessibleRole>([
     Gtk.AccessibleRole.ROW,
@@ -24,55 +28,60 @@ const SELECTABLE_ROLES: Set<Gtk.AccessibleRole> = new Set<Gtk.AccessibleRole>([
     Gtk.AccessibleRole.TREE_ITEM,
 ]);
 
-const callStringGetter = (widget: Gtk.Widget, method: string): string | null => {
-    const fn: unknown = Reflect.get(widget, method);
-
-    if (typeof fn !== "function") {
-        return null;
-    }
+const PRESSED_BY_TRISTATE: Map<number, boolean> = new Map<number, boolean>([
+    [Gtk.AccessibleTristate.FALSE, false],
+    [Gtk.AccessibleTristate.TRUE, true],
+]);
 
-    const value = (fn as () => string | null).call(widget);
+const CHECKED_BY_TRISTATE: Map<number, CheckedState> = new Map<number, CheckedState>([
+    [Gtk.AccessibleTristate.FALSE, "unchecked"],
+    [Gtk.AccessibleTristate.TRUE, "checked"],
+    [Gtk.AccessibleTristate.MIXED, "mixed"],
+]);
 
-    return value ?? null;
+const VALUE_PROPERTIES: Record<WidgetValueField, Gtk.AccessibleProperty> = {
+    now: Gtk.AccessibleProperty.VALUE_NOW,
+    min: Gtk.AccessibleProperty.VALUE_MIN,
+    max: Gtk.AccessibleProperty.VALUE_MAX,
 };
 
-const readAccessibleString = (widget: Gtk.Widget, key: string): string | null => {
-    const value = getAccessibleMetadata(widget, key);
+const readAccessibleString = (widget: Gtk.Widget, property: Gtk.AccessibleProperty): string | null =>
+    readNativeString(widget, property);
 
-    return typeof value === "string" ? value : null;
-};
+const readAccessibleNumber = (widget: Gtk.Widget, property: Gtk.AccessibleProperty): number | null =>
+    readNativeNumber(widget, property);
 
-const readAccessibleNumber = (widget: Gtk.Widget, key: string): number | null => {
-    const value = getAccessibleMetadata(widget, key);
+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);
 
-    return typeof value === "number" ? value : null;
+    return widgets.length > 0 ? widgets : null;
 };
 
-const readAccessibleWidgets = (widget: Gtk.Widget, key: string): Gtk.Widget[] | null => {
-    const value = getAccessibleMetadata(widget, key);
+const readAccessibleBoolean = (widget: Gtk.Widget, state: Gtk.AccessibleState): boolean | null =>
+    readAccessibleFlag(widget, state);
 
-    if (!Array.isArray(value)) {
-        return null;
+const getLabelText = (widget: Gtk.Widget): string | null => {
+    if (widget instanceof Gtk.Label) {
+        return widget.getLabel();
     }
 
-    const widgets = value.filter((item): item is Gtk.Widget => item instanceof Gtk.Widget);
-
-    return widgets.length > 0 ? widgets : null;
+    return readAccessibleString(widget, Gtk.AccessibleProperty.LABEL);
 };
 
-const readAccessibleBoolean = (widget: Gtk.Widget, key: string): boolean | null => {
-    const value = getAccessibleMetadata(widget, key);
+const stripMnemonic = (text: string): string => text.replaceAll(/_(.)/g, "$1");
+const isUnderlineUsed = (widget: Gtk.Widget): boolean => callBooleanGetter(widget, "getUseUnderline") ?? false;
 
-    return typeof value === "boolean" ? value : null;
-};
+const readNamingText = (widget: Gtk.Widget, getter: string, value: string): string =>
+    getter !== EDITABLE_TEXT_GETTER && isUnderlineUsed(widget) ? stripMnemonic(value) : value;
 
-const getLabelText = (widget: Gtk.Widget): string | null => {
-    if (widget instanceof Gtk.Label) {
-        return widget.getLabel();
-    }
+const readFirstText = (widget: Gtk.Widget, getters: string[]): string | null => {
+    for (const getter of getters) {
+        const value = callStringGetter(widget, getter);
 
-    if (widget instanceof Gtk.Inscription) {
-        return widget.getText() ?? null;
+        if (value) {
+            return readNamingText(widget, getter, value);
+        }
     }
 
     return null;
@@ -84,19 +93,7 @@ const getLabelText = (widget: Gtk.Widget): string | null => {
  *
  * @param widget The widget to read text from.
  */
-const getWidgetNodeText = (widget: Gtk.Widget): string | null => {
-    for (const getter of DEFAULT_TEXT_GETTERS) {
-        const value = callStringGetter(widget, getter);
-
-        if (value) {
-            return value;
-        }
-    }
-
-    return null;
-};
-
-const stripMnemonic = (text: string): string => text.replaceAll(/_(.)/g, "$1");
+const getWidgetText = (widget: Gtk.Widget): string | null => readFirstText(widget, DEFAULT_TEXT_GETTERS);
 
 const namingLabelText = (widget: Gtk.Widget): string | null => {
     const text = getLabelText(widget);
@@ -105,7 +102,7 @@ const namingLabelText = (widget: Gtk.Widget): string | null => {
         return null;
     }
 
-    return widget instanceof Gtk.Label && widget.getUseUnderline() ? stripMnemonic(text) : text;
+    return isUnderlineUsed(widget) ? stripMnemonic(text) : text;
 };
 
 const isNamingLabelRole = (role: Gtk.AccessibleRole, shouldIncludePresentation: boolean): boolean =>
@@ -136,26 +133,17 @@ const getWidgetLabelText = (widget: Gtk.Widget): string | null => {
         return null;
     }
 
-    return getLabelText(widget);
-};
-
-const getChildren = function* (widget: Gtk.Widget): Generator<Gtk.Widget> {
-    let child = widget.getFirstChild();
-
-    while (child) {
-        yield child;
-        child = child.getNextSibling();
-    }
+    return namingLabelText(widget);
 };
 
 const textContentParts = (widget: Gtk.Widget): string[] => {
-    const own = getWidgetNodeText(widget);
+    const own = getWidgetText(widget);
 
     if (own !== null) {
         return [own];
     }
 
-    return [...getChildren(widget)].flatMap((child) => textContentParts(child));
+    return [...children(widget)].flatMap((child) => textContentParts(child));
 };
 
 const getWidgetTextContent = (widget: Gtk.Widget): string | null => {
@@ -164,15 +152,15 @@ const getWidgetTextContent = (widget: Gtk.Widget): string | null => {
     return parts.length > 0 ? parts.join(" ") : null;
 };
 
-const isComboBoxFaceCandidate = (widget: Gtk.Widget): boolean =>
+const isDropDownFaceCandidate = (widget: Gtk.Widget): boolean =>
     !(widget instanceof Gtk.Popover) && widget.getChildVisible();
 
-const comboBoxChildFaceText = (child: Gtk.Widget): string | null =>
-    isComboBoxFaceCandidate(child) ? getWidgetLabelText(child) ?? comboBoxFaceText(child) : null;
+const dropDownChildFaceText = (child: Gtk.Widget): string | null =>
+    isDropDownFaceCandidate(child) ? getWidgetLabelText(child) ?? dropDownFaceText(child) : null;
 
-const comboBoxFaceText = (widget: Gtk.Widget): string | null => {
-    for (const child of getChildren(widget)) {
-        const text = comboBoxChildFaceText(child);
+const dropDownFaceText = (widget: Gtk.Widget): string | null => {
+    for (const child of children(widget)) {
+        const text = dropDownChildFaceText(child);
 
         if (text !== null) {
             return text;
@@ -192,67 +180,77 @@ const tabPanelTitle = (widget: Gtk.Widget): string | null => {
     return null;
 };
 
-const getWidgetAccessibleName = (widget: Gtk.Widget): string | null => {
-    const role = widget.getAccessibleRole();
+const nameFromAuthor = (widget: Gtk.Widget): string | null =>
+    getWidgetLabelledByText(widget) ?? readAccessibleString(widget, Gtk.AccessibleProperty.LABEL);
 
-    if (role === Gtk.AccessibleRole.TAB_PANEL) {
-        return tabPanelTitle(widget);
+const nameFromContent = (widget: Gtk.Widget): string | null => {
+    const ownText = getWidgetText(widget);
+
+    if (ownText) {
+        return ownText;
     }
 
-    const labelledByText = getWidgetLabelledByText(widget);
+    const childLabels = collectLabels(widget);
 
-    if (labelledByText) {
-        return labelledByText;
-    }
+    return childLabels.length > 0 ? childLabels.join(" ") : null;
+};
 
-    const accessibleLabel = readAccessibleString(widget, "accessibleLabel");
+const getWidgetAccessibleName = (widget: Gtk.Widget): string | null => {
+    const role = widget.getAccessibleRole();
 
-    if (accessibleLabel) {
-        return accessibleLabel;
+    if (isNameProhibited(role)) {
+        return null;
     }
 
-    const ownText = getWidgetNodeText(widget);
-
-    if (ownText) {
-        return ownText;
+    if (role === Gtk.AccessibleRole.TAB_PANEL) {
+        return tabPanelTitle(widget);
     }
 
-    const childLabels = collectLabels(widget);
+    const authored = isNameFromAuthor(role) ? nameFromAuthor(widget) : null;
 
-    if (childLabels.length > 0) {
-        return childLabels.join(" ");
+    if (authored) {
+        return authored;
     }
 
-    return callStringGetter(widget, "getTooltipText");
+    return nameFromContent(widget) ?? callStringGetter(widget, "getTooltipText");
 };
 
 const getWidgetName = (widget: Gtk.Widget): string | null => {
     return widget.getName();
 };
 
-const getWidgetPlaceholderText = (widget: Gtk.Widget): string | null => {
-    if (!EDITABLE_ROLES.has(widget.getAccessibleRole()) || !(widget instanceof Gtk.Editable)) {
-        return null;
-    }
+const nonEmptyText = (text: string | null): string | null => (text === null || text === "" ? null : text);
 
-    const fromGetter = callStringGetter(widget, "getPlaceholderText");
+const readPlaceholderProperty = (widget: Gtk.Widget): string | null => {
+    const value: unknown = Reflect.get(widget, "placeholderText");
 
-    if (fromGetter !== null) {
-        return fromGetter;
-    }
+    return typeof value === "string" ? nonEmptyText(value) : null;
+};
 
-    const fromAccessor: unknown = Reflect.get(widget, "placeholderText");
+const getWidgetPlaceholderText = (widget: Gtk.Widget): string | null => {
+    if (!EDITABLE_ROLES.has(widget.getAccessibleRole())) {
+        return null;
+    }
 
-    return typeof fromAccessor === "string" && fromAccessor !== "" ? fromAccessor : null;
+    return (
+        nonEmptyText(callStringGetter(widget, "getPlaceholderText")) ??
+        readPlaceholderProperty(widget) ??
+        nonEmptyText(readAccessibleString(widget, Gtk.AccessibleProperty.PLACEHOLDER))
+    );
 };
 
+const comboBoxDisplayValue = (widget: Gtk.Widget): string | null =>
+    widget instanceof Gtk.DropDown
+        ? (dropDownFaceText(widget) ?? getWidgetValueText(widget))
+        : (getWidgetValueText(widget) ?? dropDownFaceText(widget));
+
 const getWidgetDisplayValue = (widget: Gtk.Widget): string | null => {
     if (EDITABLE_ROLES.has(widget.getAccessibleRole()) && isEditable(widget)) {
         return readEditableText(widget);
     }
 
     if (widget.getAccessibleRole() === Gtk.AccessibleRole.COMBO_BOX) {
-        return comboBoxFaceText(widget);
+        return comboBoxDisplayValue(widget);
     }
 
     return null;
@@ -283,7 +281,7 @@ const hasZeroOpacityAncestor = (widget: Gtk.Widget): boolean => {
 const isWidgetVisible = (widget: Gtk.Widget): boolean => widget.isVisible() && !hasZeroOpacityAncestor(widget);
 
 const getWidgetRequiredState = (widget: Gtk.Widget): boolean | null =>
-    readAccessibleBoolean(widget, "accessibleRequired");
+    readAccessibleBooleanProperty(widget, Gtk.AccessibleProperty.REQUIRED);
 
 const readTextViewSelection = (view: Gtk.TextView): string | null => {
     const buffer = view.getBuffer();
@@ -292,40 +290,48 @@ const readTextViewSelection = (view: Gtk.TextView): string | null => {
     return hasSelection ? buffer.getText(start, end, true) : null;
 };
 
-const readEditableSelection = (editable: Gtk.Editable): string | null => {
-    const [hasSelection, start, end] = editable.getSelectionBounds();
+const sliceSelectedText = (widget: Gtk.Widget, start: number, end: number): string | null => {
+    const chars = getCallableMethod<[number, number], string | null>(widget, "getChars");
 
-    return hasSelection ? editable.getChars(start, end) : null;
+    if (chars) {
+        return chars(start, end) ?? null;
+    }
+
+    const text = callStringGetter(widget, "getText");
+
+    /* eslint-disable-next-line @typescript-eslint/no-misused-spread -- bounds are code point offsets */
+    return text === null ? null : [...text].slice(start, end).join("");
 };
 
-const getWidgetSelection = (widget: Gtk.Widget): string | null => {
-    if (widget instanceof Gtk.TextView) {
-        return readTextViewSelection(widget);
-    }
+const readBoundedSelection = (widget: Gtk.Widget): string | null => {
+    const bounds = getCallableMethod<[], [boolean, number, number]>(widget, "getSelectionBounds");
 
-    if (widget instanceof Gtk.Editable) {
-        return readEditableSelection(widget);
+    if (!bounds) {
+        return null;
     }
 
-    return null;
+    const [hasSelection, start, end] = bounds();
+
+    return hasSelection ? sliceSelectedText(widget, start, end) : 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 isCheckableToggle = (widget: Gtk.Widget): boolean =>
-    widget instanceof Gtk.Switch ||
-    (widget instanceof Gtk.ToggleButton && widget.getAccessibleRole() === Gtk.AccessibleRole.RADIO);
+const isRadioToggle = (widget: Gtk.Widget): widget is Gtk.ToggleButton =>
+    widget instanceof Gtk.ToggleButton && widget.getAccessibleRole() === Gtk.AccessibleRole.RADIO;
 
 const getWidgetCheckedState = (widget: Gtk.Widget): CheckedState | null => {
-    if (widget instanceof Gtk.CheckButton) {
-        return widget.getInconsistent() ? "mixed" : checkedFromActive(widget.getActive());
-    }
+    const tristate = readAccessibleState(widget, Gtk.AccessibleState.CHECKED);
+    const state = tristate === null ? undefined : CHECKED_BY_TRISTATE.get(tristate);
 
-    if (isCheckableToggle(widget)) {
-        return checkedFromActive(Reflect.get(widget, "active") === true);
+    if (state !== undefined) {
+        return state;
     }
 
-    return null;
+    return isRadioToggle(widget) ? checkedFromActive(widget.getActive()) : null;
 };
 
 const isWidgetChecked = (widget: Gtk.Widget): boolean | null => {
@@ -335,28 +341,24 @@ const isWidgetChecked = (widget: Gtk.Widget): boolean | null => {
 };
 
 const getWidgetPressedState = (widget: Gtk.Widget): boolean | null => {
-    if (widget instanceof Gtk.ToggleButton) {
-        return widget.getActive();
-    }
+    const tristate = readAccessibleState(widget, Gtk.AccessibleState.PRESSED);
 
-    return null;
+    return tristate === null ? null : PRESSED_BY_TRISTATE.get(tristate) ?? null;
 };
 
 const getWidgetExpandedState = (widget: Gtk.Widget): boolean | null => {
-    if (widget instanceof Gtk.Expander) {
-        return widget.getExpanded();
-    }
-
     if (widget instanceof Gtk.TreeExpander) {
         return widget.getListRow()?.getExpanded() ?? null;
     }
 
-    return null;
+    return readAccessibleBoolean(widget, Gtk.AccessibleState.EXPANDED);
 };
 
 const getWidgetSelectedState = (widget: Gtk.Widget): boolean | null => {
-    if (widget instanceof Gtk.ListBoxRow || widget instanceof Gtk.FlowBoxChild) {
-        return widget.isSelected();
+    const selected = readAccessibleBoolean(widget, Gtk.AccessibleState.SELECTED);
+
+    if (selected !== null) {
+        return selected;
     }
 
     if (SELECTABLE_ROLES.has(widget.getAccessibleRole())) {
@@ -367,88 +369,37 @@ const getWidgetSelectedState = (widget: Gtk.Widget): boolean | null => {
 };
 
 const getWidgetLevel = (widget: Gtk.Widget): number | null => {
-    return readAccessibleNumber(widget, "accessibleLevel");
+    return readAccessibleInt(widget, Gtk.AccessibleProperty.LEVEL);
 };
 
 const getWidgetInvalidState = (widget: Gtk.Widget): Gtk.AccessibleInvalidState | null => {
-    const value = readAccessibleNumber(widget, "accessibleInvalid");
+    const value = readAccessibleState(widget, Gtk.AccessibleState.INVALID);
 
     return value ?? null;
 };
 
 const getWidgetErrorMessage = (widget: Gtk.Widget): Gtk.Widget[] | null =>
-    readAccessibleWidgets(widget, "accessibleErrorMessage");
+    readAccessibleWidgets(widget, Gtk.AccessibleRelation.ERROR_MESSAGE);
 
 const getWidgetBusyState = (widget: Gtk.Widget): boolean | null => {
-    return readAccessibleBoolean(widget, "accessibleBusy");
+    return readAccessibleBoolean(widget, Gtk.AccessibleState.BUSY);
 };
 
 const getWidgetDescription = (widget: Gtk.Widget): string | null => {
-    return readAccessibleString(widget, "accessibleDescription");
-};
-
-const adjustmentValue = (adjustment: Gtk.Adjustment): ValueTriplet => ({
-    now: adjustment.getValue(),
-    min: adjustment.getLower(),
-    max: adjustment.getUpper(),
-});
-
-const adjustmentWidgetValue = (widget: Gtk.Widget): ValueTriplet | null => {
-    if (widget instanceof Gtk.Range) {
-        return adjustmentValue(widget.getAdjustment());
-    }
-
-    if (widget instanceof Gtk.Scrollbar) {
-        return adjustmentValue(widget.getAdjustment());
-    }
-
-    if (widget instanceof Gtk.SpinButton) {
-        return adjustmentValue(widget.getAdjustment());
-    }
-
-    if (widget instanceof Gtk.ScaleButton) {
-        return adjustmentValue(widget.getAdjustment());
-    }
-
-    return null;
-};
-
-const getWidgetLiveValue = (widget: Gtk.Widget): ValueTriplet | null => {
-    const adjustmentBased = adjustmentWidgetValue(widget);
-
-    if (adjustmentBased) {
-        return adjustmentBased;
-    }
-
-    if (widget instanceof Gtk.LevelBar) {
-        return { now: widget.getValue(), min: widget.getMinValue(), max: widget.getMaxValue() };
-    }
-
-    if (widget instanceof Gtk.ProgressBar) {
-        return { now: widget.getFraction(), min: 0, max: 1 };
-    }
-
-    return null;
+    return readAccessibleString(widget, Gtk.AccessibleProperty.DESCRIPTION);
 };
 
-const getWidgetValue = (widget: Gtk.Widget): WidgetValue => {
-    const text = readAccessibleString(widget, "accessibleValueText");
-    const live = getWidgetLiveValue(widget);
+const getWidgetValueNow = (widget: Gtk.Widget): number | null =>
+    readAccessibleNumber(widget, Gtk.AccessibleProperty.VALUE_NOW);
 
-    if (live) {
-        return { ...live, text };
-    }
+const getWidgetValueText = (widget: Gtk.Widget): string | null =>
+    readAccessibleString(widget, Gtk.AccessibleProperty.VALUE_TEXT);
 
-    return {
-        now: readAccessibleNumber(widget, "accessibleValueNow"),
-        min: readAccessibleNumber(widget, "accessibleValueMin"),
-        max: readAccessibleNumber(widget, "accessibleValueMax"),
-        text,
-    };
-};
+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, "accessibleLabel");
+    return readAccessibleString(widget, Gtk.AccessibleProperty.LABEL);
 };
 
 const collectAccessibleNames = (targets: Gtk.Widget[]): string[] => {
@@ -457,7 +408,7 @@ const collectAccessibleNames = (targets: Gtk.Widget[]): string[] => {
     for (const target of targets) {
         const text = getWidgetAccessibleName(target);
 
-        if (text !== null) {
+        if (text) {
             texts.push(text);
         }
     }
@@ -465,8 +416,14 @@ const collectAccessibleNames = (targets: Gtk.Widget[]): string[] => {
     return texts;
 };
 
+const isSelfLabelling = (widget: Gtk.Widget, targets: Gtk.Widget[]): boolean => {
+    const own = new Set(descendants(widget));
+
+    return targets.every((target) => own.has(target));
+};
+
 const getWidgetLabelledByText = (widget: Gtk.Widget): string | null => {
-    const targets = readAccessibleWidgets(widget, "accessibleLabelledBy");
+    const targets = readAccessibleWidgets(widget, Gtk.AccessibleRelation.LABELLED_BY);
 
     if (targets === null) {
         return null;
@@ -477,20 +434,26 @@ const getWidgetLabelledByText = (widget: Gtk.Widget): string | null => {
     return texts.length > 0 ? texts.join(" ") : null;
 };
 
+const getWidgetExternalLabelText = (widget: Gtk.Widget): string | null => {
+    const targets = readAccessibleWidgets(widget, Gtk.AccessibleRelation.LABELLED_BY);
+
+    return targets === null || isSelfLabelling(widget, targets) ? null : getWidgetLabelledByText(widget);
+};
+
 const isTooltipUsedAsName = (widget: Gtk.Widget): boolean =>
-    readAccessibleString(widget, "accessibleLabel") === null &&
-    getWidgetNodeText(widget) === null &&
+    readAccessibleString(widget, Gtk.AccessibleProperty.LABEL) === null &&
+    getWidgetText(widget) === null &&
     collectLabels(widget).length === 0;
 
 const getWidgetDescribedByText = (widget: Gtk.Widget): string | null => {
-    const targets = readAccessibleWidgets(widget, "accessibleDescribedBy");
+    const targets = readAccessibleWidgets(widget, Gtk.AccessibleRelation.DESCRIBED_BY);
     const texts = targets === null ? [] : collectAccessibleNames(targets);
 
     if (texts.length > 0) {
         return texts.join(" ");
     }
 
-    const description = readAccessibleString(widget, "accessibleDescription");
+    const description = readAccessibleString(widget, Gtk.AccessibleProperty.DESCRIPTION);
 
     if (description !== null) {
         return description;
@@ -499,15 +462,17 @@ const getWidgetDescribedByText = (widget: Gtk.Widget): string | null => {
     return isTooltipUsedAsName(widget) ? null : callStringGetter(widget, "getTooltipText");
 };
 
+/**
+ * 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 (!current.getVisible()) {
-            return true;
-        }
-
-        if (readAccessibleBoolean(current, "accessibleHidden") === true) {
+        if (readAccessibleBoolean(current, Gtk.AccessibleState.HIDDEN) === true) {
             return true;
         }
 
@@ -518,7 +483,8 @@ const isInaccessible = (widget: Gtk.Widget): boolean => {
 };
 
 export {
-    getWidgetNodeText,
+    namingLabelText,
+    getWidgetText,
     getWidgetTextContent,
     getWidgetLabelText,
     getWidgetAccessibleName,
@@ -541,10 +507,13 @@ export {
     getWidgetErrorMessage,
     getWidgetBusyState,
     getWidgetDescription,
-    getWidgetValue,
+    getWidgetValueNow,
+    getWidgetValueText,
     getWidgetOwnLabel,
+    getWidgetExternalLabelText,
     getWidgetLabelledByText,
     isInaccessible,
+    isWidgetValueMatch,
     type CheckedState,
-    type WidgetValue,
+    type WidgetValueField,
 };

package/src/widget-getters.ts

@@ -0,0 +1,32 @@
+import type * as Gtk from "@gtkx/gi/gtk";
+import { getInstanceType, typeName } from "@gtkx/runtime";
+
+const getWidgetMethod = (widget: Gtk.Widget, name: string): unknown => Reflect.get(widget, name);
+const getWidgetTypeName = (widget: Gtk.Widget): string | null => typeName(getInstanceType(widget));
+
+const hasWidgetMethod = (widget: Gtk.Widget, 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,
+    name: string,
+): ((...args: Args) => Result) | null => {
+    const fn = getWidgetMethod(widget, name);
+
+    return typeof fn === "function" ? (fn as (...args: Args) => Result).bind(widget) : null;
+};
+
+const callBooleanGetter = (widget: Gtk.Widget, 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 value = getCallableMethod<[], unknown>(widget, method)?.();
+
+    return typeof value === "string" ? value : null;
+};
+
+export { callBooleanGetter, callStringGetter, getCallableMethod, getWidgetTypeName, hasWidgetMethod };