@gtkx/testing 1.0.0-rc.4 → 1.0.0

package/src/types.ts

@@ -55,13 +55,19 @@ type MatcherOptions<T extends Gtk.Widget = Gtk.Widget> = {
     as?: WidgetType<T> | undefined;
 } & WaitForOptions;
 
-/** Constraints on a widget's numeric range value used by role queries. */
+/**
+ * Constraints on a widget's numeric range value used by role queries. The numbers come from the
+ * accessibility tree and match within 0.001, the resolution GTK keeps them to.
+ */
 type ByRoleValue = {
     /** The current value. */
     now?: number | undefined;
     /** The lower bound of the value's range. */
     min?: number | undefined;
-    /** The upper bound of the value's range. */
+    /**
+     * The highest value the widget can reach, which on a paged widget such as a scrollbar is its
+     * adjustment's upper bound less one page.
+     */
     max?: number | undefined;
     /** Matcher for the value's textual representation. */
     text?: Matcher | undefined;
@@ -87,7 +93,7 @@ type ByRoleOptions<T extends Gtk.Widget = Gtk.Widget> = MatcherOptions<T> & {
     description?: Matcher | undefined;
     /** Constraints on the widget's range value, each checked only when given. */
     value?: ByRoleValue | undefined;
-    /** When true, include widgets excluded from the accessibility tree. */
+    /** When true, include widgets excluded from the accessibility tree. Widgets that are not mapped stay excluded. */
     hidden?: boolean | undefined;
 };
 
@@ -187,8 +193,11 @@ type DebugUtilities = {
     debug: (element?: Container | Container[], options?: PrettyWidgetOptions) => void;
     /** Prints the accessible roles found in the scope, with the widgets carrying each one. */
     logRoles: () => void;
-    /** Captures a window, writes the image to a temporary file, and logs its path. */
-    screenshot: (selector?: WindowSelector, options?: ScreenshotOptions) => Promise<ScreenshotResult>;
+    /**
+     * Captures what is on screen, which is the active toplevel window: GTK4 exposes no position for
+     * a toplevel, so windows cannot be composited into a single image.
+     */
+    screenshot: (options?: ScreenshotOptions) => Promise<ScreenshotResult>;
 };
 
 /** A captured screenshot: base64-encoded image data, its MIME type, and pixel dimensions. */
@@ -203,26 +212,27 @@ type ScreenshotResult = {
     height: number;
 };
 
-/** Options for capturing a screenshot: the poll timeout and interval, plus a rendering scale factor. */
+/**
+ * Options for capturing a screenshot: the poll timeout and interval, a rendering scale factor, and
+ * a file to write the PNG to.
+ */
 type ScreenshotOptions = Pick<WaitForOptions, "timeout" | "interval"> & {
     /** Device scale factor applied when rendering. */
-    scale?: number;
+    scale?: number | undefined;
+    /** File the PNG is written to, with its parent directories created as needed. */
+    path?: string | undefined;
 };
 
-/**
- * Selects the window to screenshot by index, or by title (exact string or regular expression);
- * undefined targets the default window.
- */
-type WindowSelector = number | string | RegExp | undefined;
-
 /**
  * Options for {@link renderHook}: an optional wrapper and the initial props (required unless the
  * props type permits undefined).
  */
 type RenderHookOptions<Props> = {
+    /** Component wrapped around the one calling the hook, such as a context provider. */
     wrapper?: WrapperComponent;
 } & (undefined extends Props
     ? {
+            /** Props the hook is invoked with until `rerender` is given new ones. */
             initialProps?: Props;
         }
     : {
@@ -234,8 +244,11 @@ type RenderHookOptions<Props> = {
  * props and to unmount.
  */
 type RenderHookResult<Result, Props> = {
-    /** Holds the most recent value returned by the hook under `current`. */
-    result: { current: Result };
+    /** Stable object the hook's return value is written to on every render. */
+    result: {
+        /** The hook's latest return value. */
+        current: Result;
+    };
     /** Re-invokes the hook, keeping the previous props when none are given. */
     rerender: (newProps?: Props) => Promise<void>;
     /** Unmounts the component that calls the hook. */
@@ -260,7 +273,6 @@ export {
     type DebugUtilities,
     type ScreenshotResult,
     type ScreenshotOptions,
-    type WindowSelector,
     type RenderHookOptions,
     type RenderHookResult,
 };

package/src/user-event/adjustment.ts

@@ -1,4 +1,5 @@
 import * as Gtk from "@gtkx/gi/gtk";
+import { scheduleNextFrame } from "../frame-sync.js";
 import { wrapEvent } from "./event-wrapper.js";
 
 /** A scroll distance in pixels along each axis. */
@@ -44,22 +45,47 @@ const resolveScrollAdjustments = (widget: Gtk.Widget): ScrollAdjustments | null
     return null;
 };
 
+const stepToward = (adjustment: Gtk.Adjustment, target: number, step: number): number => {
+    const value = adjustment.getValue();
+    adjustment.setValue(value < target ? Math.min(value + step, target) : Math.max(value - step, target));
+
+    return adjustment.getValue();
+};
+
+const rampTo = (adjustment: Gtk.Adjustment, target: number, step: number): void => {
+    let value = adjustment.getValue();
+
+    while (value !== target) {
+        const moved = stepToward(adjustment, target, step);
+
+        if (moved === value) {
+            return;
+        }
+
+        value = moved;
+    }
+};
+
 const applyScrollDelta = (adjustment: Gtk.Adjustment | null, delta: number): void => {
     if (!adjustment || delta === 0) {
         return;
     }
 
-    adjustment.setValue(adjustment.getValue() + delta);
+    const pageSize = adjustment.getPageSize();
+    rampTo(adjustment, adjustment.getValue() + delta, pageSize > 0 ? pageSize : Math.abs(delta));
 };
 
 /**
  * Adds the delta to the adjustments of the widget itself, or of its nearest Gtk.ScrolledWindow or
  * Gtk.Scrollable ancestor.
  *
+ * Each adjustment advances in viewport-sized steps rather than one jump, so virtualized views such
+ * as Gtk.ListView, Gtk.GridView and Gtk.ColumnView re-anchor onto the rows the new offset shows.
+ *
  * @throws When neither the widget nor any of its ancestors is scrollable.
  */
 const scroll = (widget: Gtk.Widget, delta: ScrollDelta): Promise<void> =>
-    wrapEvent(widget, () => {
+    wrapEvent(widget, async () => {
         const adjustments = resolveScrollAdjustments(widget);
 
         if (!adjustments) {
@@ -70,6 +96,7 @@ const scroll = (widget: Gtk.Widget, delta: ScrollDelta): Promise<void> =>
 
         applyScrollDelta(adjustments.horizontal, delta.x ?? 0);
         applyScrollDelta(adjustments.vertical, delta.y ?? 0);
+        await scheduleNextFrame(widget);
     });
 
 export { slide, scroll, type ScrollDelta };

package/src/user-event/click.ts

@@ -1,8 +1,29 @@
+import * as Gdk from "@gtkx/gi/gdk";
 import * as Gtk from "@gtkx/gi/gtk";
-import { getOrCreateControllers, queryController } from "./controller.js";
+import { hasSignalListener } from "@gtkx/runtime/internal";
+import { callBooleanGetter, getCallableMethod, hasWidgetMethod } from "../widget-getters.js";
+import { queryAllControllers } from "./controller.js";
 import { wrapEvent } from "./event-wrapper.js";
+import { hasIndexedChildren, selectContainerChild, SELECTED_PROBE, unselectOtherChildren } from "./indexed-children.js";
+import { isClickTransparent, type NativeClick, nativeClickFor } from "./native-click.js";
 
-const getPressPoint = (widget: Gtk.Widget): { x: number; y: number } => {
+type PressPoint = { x: number; y: number };
+type ClickPhase = "pressed" | "released";
+type ClickSite = { gestures: Gtk.GestureClick[]; point: PressPoint };
+type ClickScope = { isClicked: boolean; isInternalAllowed: boolean };
+
+type ClickTarget = {
+    widget: Gtk.Widget;
+    container: Gtk.Widget | null;
+    gestures: Gtk.GestureClick[];
+    isClaiming: boolean;
+    native: NativeClick | null;
+};
+
+const CLICK_SIGNALS = ["pressed", "released"];
+const PRIMARY_BUTTONS: Set<number> = new Set([0, Gdk.BUTTON_PRIMARY]);
+
+const getCenterPoint = (widget: Gtk.Widget): PressPoint => {
     const width = widget.getWidth();
     const height = widget.getHeight();
 
@@ -13,46 +34,205 @@ const getPressPoint = (widget: Gtk.Widget): { x: number; y: number } => {
     return { x: 0, y: 0 };
 };
 
-const emitGesture = (widget: Gtk.Widget, controllers: Gtk.GestureClick[], nPress: number, signal: string): void => {
-    const { x, y } = getPressPoint(widget);
+const getClickPoint = (clicked: Gtk.Widget, carrier: Gtk.Widget): PressPoint => {
+    if (clicked === carrier) {
+        return getCenterPoint(clicked);
+    }
+
+    const [isComputed, bounds] = clicked.computeBounds(carrier);
 
+    if (!isComputed) {
+        return getCenterPoint(carrier);
+    }
+
+    return { x: bounds.getX() + bounds.getWidth() / 2, y: bounds.getY() + bounds.getHeight() / 2 };
+};
+
+const emitGesture = (point: PressPoint, controllers: Gtk.GestureClick[], nPress: number, signal: string): void => {
     for (const controller of controllers) {
-        controller.emit(signal, nPress, x, y);
+        controller.emit(signal, nPress, point.x, point.y);
     }
 };
 
-const emitPress = (widget: Gtk.Widget, controllers: Gtk.GestureClick[], nPress: number): void => {
-    emitGesture(widget, controllers, nPress, "pressed");
+const emitClickPhase = (
+    widget: Gtk.Widget,
+    controllers: Gtk.GestureClick[],
+    nPress: number,
+    phase: ClickPhase,
+): void => {
+    emitGesture(getCenterPoint(widget), controllers, nPress, phase);
 };
 
-const emitRelease = (widget: Gtk.Widget, controllers: Gtk.GestureClick[], nPress: number): void => {
-    emitGesture(widget, controllers, nPress, "released");
+const emitSitePhase = (sites: ClickSite[], nPress: number, phase: ClickPhase): void => {
+    for (const site of sites) {
+        emitGesture(site.point, site.gestures, nPress, phase);
+    }
 };
 
-const emitClickSequence = (widget: Gtk.Widget, target: Gtk.Widget, nPress: number): Promise<void> =>
-    wrapEvent(widget, () => {
-        const controllers = getOrCreateControllers(target, Gtk.GestureClick);
+const emitClickSequence = (sites: ClickSite[], nPress: number): void => {
+    for (let i = 1; i <= nPress; i++) {
+        emitSitePhase(sites, i, "pressed");
+        emitSitePhase(sites, i, "released");
+    }
+};
 
-        for (let i = 1; i <= nPress; i++) {
-            emitPress(target, controllers, i);
-            emitRelease(target, controllers, i);
-        }
-    });
+const containerFor = (widget: Gtk.Widget): Gtk.Widget | null => {
+    const parent = widget.getParent();
 
-const findClickableAncestor = (widget: Gtk.Widget): Gtk.Widget | null => {
-    let current = widget.getParent();
+    return parent !== null && hasWidgetMethod(widget, SELECTED_PROBE) && hasIndexedChildren(parent) ? parent : null;
+};
 
-    while (current) {
-        if (current instanceof Gtk.Button || queryController(current, Gtk.GestureClick) !== null) {
-            return current;
-        }
+const hasClickHandlers = (gesture: Gtk.GestureClick): boolean => hasSignalListener(gesture, CLICK_SIGNALS);
+const isInternalGesture = (gesture: Gtk.GestureClick): boolean => !hasSignalListener(gesture);
+const isPrimaryGesture = (gesture: Gtk.GestureClick): boolean => PRIMARY_BUTTONS.has(gesture.getButton());
+
+const clickGestures = (widget: Gtk.Widget): Gtk.GestureClick[] =>
+    queryAllControllers(widget, Gtk.GestureClick).filter((gesture) => isPrimaryGesture(gesture));
+
+const getAuthoredClickGestures = (widget: Gtk.Widget): Gtk.GestureClick[] =>
+    clickGestures(widget).filter((gesture) => hasClickHandlers(gesture));
+
+const isClaimingTarget = (widget: Gtk.Widget): boolean =>
+    widget instanceof Gtk.Button || containerFor(widget) !== null;
+
+const gestureTargetFor = (widget: Gtk.Widget, isInternalAllowed: boolean): ClickTarget | null => {
+    const gestures = clickGestures(widget);
+
+    if (isClaimingTarget(widget)) {
+        return { widget, container: containerFor(widget), gestures, isClaiming: true, native: null };
+    }
 
-        current = current.getParent();
+    const authored = gestures.filter((gesture) => hasClickHandlers(gesture));
+
+    if (authored.length > 0) {
+        return { widget, container: null, gestures: authored, isClaiming: false, native: null };
+    }
+
+    if (isInternalAllowed && gestures.some((gesture) => isInternalGesture(gesture))) {
+        return { widget, container: null, gestures, isClaiming: true, native: null };
     }
 
     return null;
 };
 
+const clickTargetFor = (widget: Gtk.Widget, scope: ClickScope): ClickTarget | null => {
+    if (isClickTransparent(widget)) {
+        return null;
+    }
+
+    const native = nativeClickFor(widget, scope.isClicked);
+
+    if (native !== null) {
+        return { widget, container: null, gestures: getAuthoredClickGestures(widget), isClaiming: true, native };
+    }
+
+    return gestureTargetFor(widget, scope.isInternalAllowed);
+};
+
+const isSelfClickTarget = (widget: Gtk.Widget): boolean =>
+    isClickTransparent(widget) || clickTargetFor(widget, { isClicked: true, isInternalAllowed: false }) !== null;
+
+const nextClickWidget = (current: Gtk.Widget, target: ClickTarget | null): Gtk.Widget | null =>
+    target?.isClaiming === true ? null : current.getParent();
+
+const collectClickTargets = (widget: Gtk.Widget): ClickTarget[] => {
+    const targets: ClickTarget[] = [];
+    let current: Gtk.Widget | null = widget;
+
+    while (current !== null) {
+        const isClicked = current === widget;
+        const scope = { isClicked, isInternalAllowed: !isClicked && targets.length === 0 };
+        const target = clickTargetFor(current, scope);
+        const next = nextClickWidget(current, target);
+
+        if (target !== null) {
+            targets.push(target);
+        }
+
+        current = next;
+    }
+
+    return targets;
+};
+
+const targetSites = (clicked: Gtk.Widget, target: ClickTarget): ClickSite[] => {
+    const { container } = target;
+    const site = { gestures: target.gestures, point: getClickPoint(clicked, target.widget) };
+
+    if (container === null) {
+        return [site];
+    }
+
+    return [site, { gestures: getAuthoredClickGestures(container), point: getClickPoint(clicked, container) }];
+};
+
+const isSingleClickActivating = (container: Gtk.Widget): boolean =>
+    callBooleanGetter(container, "getActivateOnSingleClick") ?? true;
+
+const isMultipleSelection = (container: Gtk.Widget): boolean =>
+    getCallableMethod<[], Gtk.SelectionMode>(container, "getSelectionMode")?.() === Gtk.SelectionMode.MULTIPLE;
+
+const isChildSelectable = (child: Gtk.Widget): boolean => callBooleanGetter(child, "getSelectable") ?? true;
+
+const replaceContainerSelection = (container: Gtk.Widget, child: Gtk.Widget): void => {
+    if (!isChildSelectable(child)) {
+        return;
+    }
+
+    selectContainerChild(container, child);
+
+    if (isMultipleSelection(container)) {
+        unselectOtherChildren(container, child);
+    }
+};
+
+const isActivatedByClick = (container: Gtk.Widget, nPress: number): boolean =>
+    isSingleClickActivating(container) || nPress > 1;
+
+const isSelectionReplacedByClick = (container: Gtk.Widget, nPress: number): boolean =>
+    nPress > 1 || !isSingleClickActivating(container);
+
+const applyContainerOutcome = (target: ClickTarget, nPress: number): void => {
+    const { container, widget } = target;
+
+    if (container === null || widget.getParent() !== container) {
+        return;
+    }
+
+    if (isActivatedByClick(container, nPress)) {
+        widget.activate();
+    }
+
+    if (isSelectionReplacedByClick(container, nPress)) {
+        replaceContainerSelection(container, widget);
+    }
+};
+
+const applyClickOutcome = (target: ClickTarget, nPress: number): void => {
+    if (target.native === null) {
+        applyContainerOutcome(target, nPress);
+
+        return;
+    }
+
+    target.native(target.widget, nPress);
+};
+
+const applyClickOutcomes = (targets: ClickTarget[], nPress: number): void => {
+    for (const target of targets) {
+        applyClickOutcome(target, nPress);
+    }
+};
+
+const deliverClick = (widget: Gtk.Widget, nPress: number): Promise<void> =>
+    wrapEvent(widget, () => {
+        const targets = collectClickTargets(widget);
+        const sites = targets.flatMap((target) => targetSites(widget, target));
+        emitClickSequence(sites, nPress);
+        applyClickOutcomes(targets, nPress);
+    });
+
+/* eslint-disable-next-line unicorn/consistent-boolean-name -- the boolean reports whether activation succeeded */
 const tryActivate = async (widget: Gtk.Widget): Promise<boolean> => {
     if (widget.getAccessibleRole() === Gtk.AccessibleRole.LABEL) {
         return false;
@@ -68,39 +248,54 @@ const tryActivate = async (widget: Gtk.Widget): Promise<boolean> => {
 };
 
 /**
- * Presses and releases a Gtk.Button, flips a Gtk.Switch, and otherwise activates the widget,
- * falling back to a click gesture on the nearest Gtk.Button or click-gesture ancestor when
- * activation does nothing. A widget with the label role is never activated.
+ * Activates a widget that neither claims the click nor carries a click gesture of its own, and
+ * otherwise delivers a press and release. The press travels outwards from the clicked widget
+ * through every widget carrying a click gesture with a pressed or released handler, the way GTK
+ * hands the same press to each of them, and stops at the first Gtk.Button or indexed child of a
+ * list box or flow box, which claims it. A gesture GTK attached itself takes the press only when no
+ * widget below it handles one, and stops it there, so an expander or a notebook tab nested in a row
+ * opens instead of activating the row. Coordinates are the clicked widget's position in each
+ * carrier, so a gesture the container of an indexed child carries reads the child's position rather
+ * than the container's center. An indexed child that the press reaches is then activated, or
+ * exclusively selected when its container does not activate on a single click. A widget with the
+ * label role is never activated, but does consume the click when it carries a gesture of its own.
+ *
+ * The press also stops at a widget whose click GTK4 implements in C on a gesture it attached
+ * itself, reading a GdkEvent that off-screen synthesis cannot produce. Gestures that widget carries
+ * of its own still take the press and release, the way GTK hands them the press before its own
+ * gesture claims it, and the same outcome is then applied through the public action GTK's own
+ * handler invokes: a list, grid, or column-view row is focused and selected, and activated as well
+ * on a second press or when its view activates on a single click; an expandable tree expander
+ * toggles its expansion, once per press, and only when it is the widget clicked, so a click on its
+ * child falls through to the enclosing row; a column header sorts by its column. Sorting goes
+ * through Gtk.ColumnView.sortByColumn, so the primary sort column and order match what a pointer
+ * produces while previously sorted columns are dropped rather than kept as secondary keys. A
+ * column-view cell and the row that carries the column headers stand in the way of the click rather
+ * than taking it, so a click on either reaches the row or the view behind it.
  */
 const click = async (widget: Gtk.Widget): Promise<void> => {
-    if (widget instanceof Gtk.Button) {
-        await emitClickSequence(widget, widget, 1);
-
-        return;
-    }
-
-    if (widget instanceof Gtk.Switch) {
-        await wrapEvent(widget, () => {
-            widget.setActive(!widget.getActive());
-        });
-
-        return;
-    }
-
-    if (await tryActivate(widget)) {
+    if (!isSelfClickTarget(widget) && (await tryActivate(widget))) {
         return;
     }
 
-    const target = findClickableAncestor(widget);
-
-    if (target) {
-        await emitClickSequence(widget, target, 1);
-    }
+    await deliverClick(widget, 1);
 };
 
-/** Emits a two-press click gesture at the widget's center, adding a Gtk.GestureClick when it has none. */
-const dblClick = (widget: Gtk.Widget): Promise<void> => emitClickSequence(widget, widget, 2);
-/** Emits a three-press click gesture at the widget's center, adding a Gtk.GestureClick when it has none. */
-const tripleClick = (widget: Gtk.Widget): Promise<void> => emitClickSequence(widget, widget, 3);
+/**
+ * Delivers a two-press click gesture the way {@link click} delivers a single press, without trying
+ * activation first. A list box row or flow box child the presses reach, clicked directly or through
+ * a descendant, is activated and exclusively selected, as GTK's double-click path does whether or
+ * not the container activates on a single click. A widget whose click GTK4 implements itself
+ * receives that outcome once per press, so a list, grid, or column-view row is selected and then
+ * activated by the second press, a tree expander ends back where it started, and a column header
+ * sorts and then inverts its order.
+ */
+const dblClick = (widget: Gtk.Widget): Promise<void> => deliverClick(widget, 2);
+/**
+ * Delivers a three-press click gesture the same way a double click is delivered, applying the same
+ * outcome to a list box row or flow box child the presses reach, and applying the outcome GTK4
+ * implements itself once per press to a row, tree expander, or column header.
+ */
+const tripleClick = (widget: Gtk.Widget): Promise<void> => deliverClick(widget, 3);
 
-export { emitPress, emitRelease, click, dblClick, tripleClick };
+export { clickGestures, emitClickPhase, getAuthoredClickGestures, click, dblClick, tripleClick };

package/src/user-event/column-header-click.ts

@@ -0,0 +1,90 @@
+import * as Gtk from "@gtkx/gi/gtk";
+import { children } from "../traversal.js";
+import { getWidgetTextContent } from "../widget-accessible-properties.js";
+
+const columnViewFor = (header: Gtk.Widget): Gtk.ColumnView | null => {
+    let current: Gtk.Widget | null = header.getParent();
+
+    while (current !== null) {
+        if (current instanceof Gtk.ColumnView) {
+            return current;
+        }
+
+        current = current.getParent();
+    }
+
+    return null;
+};
+
+const columnsFor = (view: Gtk.ColumnView): Gtk.ColumnViewColumn[] => {
+    const model = view.getColumns();
+    const columns: Gtk.ColumnViewColumn[] = [];
+
+    for (let index = 0; index < model.getNItems(); index++) {
+        const column = model.getItem(index);
+
+        if (column instanceof Gtk.ColumnViewColumn) {
+            columns.push(column);
+        }
+    }
+
+    return columns;
+};
+
+const headerIndexFor = (header: Gtk.Widget): number => {
+    const parent = header.getParent();
+
+    return parent === null ? -1 : [...children(parent)].indexOf(header);
+};
+
+const titledColumnFor = (columns: Gtk.ColumnViewColumn[], title: string | null): Gtk.ColumnViewColumn | null => {
+    const matches = columns.filter((column) => column.getTitle() === title);
+
+    return matches.length === 1 ? matches[0] ?? null : null;
+};
+
+const columnFor = (header: Gtk.Widget, view: Gtk.ColumnView): Gtk.ColumnViewColumn | null => {
+    const columns = columnsFor(view);
+    const picked = columns[headerIndexFor(header)] ?? null;
+    const title = getWidgetTextContent(header);
+
+    if (picked !== null && picked.getTitle() === title) {
+        return picked;
+    }
+
+    return titledColumnFor(columns, title) ?? picked;
+};
+
+const sortableColumnFor = (header: Gtk.Widget, view: Gtk.ColumnView): Gtk.ColumnViewColumn | null => {
+    const column = columnFor(header, view);
+
+    return column !== null && column.getSorter() !== null ? column : null;
+};
+
+const invertedSortDirection = (order: Gtk.SortType): Gtk.SortType =>
+    order === Gtk.SortType.ASCENDING ? Gtk.SortType.DESCENDING : Gtk.SortType.ASCENDING;
+
+const nextSortDirection = (view: Gtk.ColumnView, column: Gtk.ColumnViewColumn): Gtk.SortType => {
+    const sorter = view.getSorter();
+
+    if (!(sorter instanceof Gtk.ColumnViewSorter) || sorter.getPrimarySortColumn() !== column) {
+        return Gtk.SortType.ASCENDING;
+    }
+
+    return invertedSortDirection(sorter.getPrimarySortOrder());
+};
+
+const applyHeaderClick = (header: Gtk.Widget, nPress: number): void => {
+    const view = columnViewFor(header);
+    const column = view === null ? null : sortableColumnFor(header, view);
+
+    if (view === null || column === null) {
+        return;
+    }
+
+    for (let press = 1; press <= nPress; press++) {
+        view.sortByColumn(column, nextSortDirection(view, column));
+    }
+};
+
+export { applyHeaderClick };

package/src/user-event/event-wrapper.ts

@@ -14,7 +14,9 @@ const canDisplayDeliverActivation = (window: Gtk.Window): boolean =>
     window.getDisplay().getDefaultSeat() !== null;
 
 const findWindowActionabilityFailure = (widget: Gtk.Widget, root: Gtk.Window): string | null => {
-    if (root.getAllocatedWidth() === 0) {
+    const [isComputed, allocation] = root.computeBounds(root);
+
+    if (!isComputed || allocation.getWidth() === 0) {
         return WINDOW_NOT_ALLOCATED;
     }