@gtkx/testing 1.0.0-rc.1 → 1.0.0-rc.2

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

@@ -10,22 +10,44 @@ const WINDOW_NOT_ACTIVE = "its window never became active";
 
 const actionableHop = (): Promise<void> => new Promise((resolve) => setTimeout(resolve, 1));
 
-const displayDeliversActivation = (window: Gtk.Window): boolean => window.getDisplay().getDefaultSeat() !== null;
+const canDisplayDeliverActivation = (window: Gtk.Window): boolean =>
+    window.getDisplay().getDefaultSeat() !== null;
+
+const findWindowActionabilityFailure = (widget: Gtk.Widget, root: Gtk.Window): string | null => {
+    if (root.getAllocatedWidth() === 0) {
+        return WINDOW_NOT_ALLOCATED;
+    }
+
+    if (!widget.getMapped()) {
+        return NOT_MAPPED;
+    }
+
+    if (canDisplayDeliverActivation(root) && !root.isActive()) {
+        return WINDOW_NOT_ACTIVE;
+    }
+
+    return null;
+};
 
 const findActionabilityFailure = (widget: Gtk.Widget): string | null => {
-    if (!widget.isSensitive()) return NOT_SENSITIVE;
+    if (!widget.isSensitive()) {
+        return NOT_SENSITIVE;
+    }
+
     const root = widget.getRoot();
-    if (!(root instanceof Gtk.Window) || !root.getVisible()) return null;
-    if (root.getAllocatedWidth() === 0) return WINDOW_NOT_ALLOCATED;
-    if (!widget.getMapped()) return NOT_MAPPED;
-    if (displayDeliversActivation(root) && !root.isActive()) return WINDOW_NOT_ACTIVE;
-    return null;
+
+    if (!(root instanceof Gtk.Window) || !root.getVisible()) {
+        return null;
+    }
+
+    return findWindowActionabilityFailure(widget, root);
 };
 
 const describeWidget = (widget: Gtk.Widget): string => {
     const tag = widget.constructor.name;
     const name = widget.getName();
     const nameAttribute = name && !name.endsWith(tag) ? ` name="${name}"` : "";
+
     return `<${tag}${nameAttribute} role="${formatRole(widget.getAccessibleRole())}">`;
 };
 
@@ -33,22 +55,26 @@ const waitForActionable = async (widget: Gtk.Widget): Promise<void> => {
     const timeout = getConfig().actionabilityTimeout;
     const deadline = Date.now() + timeout;
     let failure = findActionabilityFailure(widget);
+
     while (failure !== null && Date.now() < deadline) {
         await actionableHop();
         failure = findActionabilityFailure(widget);
     }
+
     if (failure !== null) {
         throw new Error(
-            `Cannot dispatch user event: ${describeWidget(widget)} did not become actionable within ${timeout}ms because ${failure}`,
+            `Cannot dispatch user event: ${describeWidget(widget)} did not become actionable ` +
+            `within ${String(timeout)}ms because ${failure}`,
         );
     }
 };
 
-export const wrapEvent = (widget: Gtk.Widget, body: () => void | PromiseLike<void>): Promise<void> =>
-    Promise.resolve()
-        .then(() => waitForActionable(widget))
-        .then(() =>
-            runInAct(async () => {
-                await body();
-            }),
-        );
+const wrapEvent = async (widget: Gtk.Widget, body: () => void | PromiseLike<void>): Promise<void> => {
+    await waitForActionable(widget);
+
+    await runInAct(async () => {
+        await body();
+    });
+};
+
+export { wrapEvent };

package/src/user-event/gesture.ts

@@ -5,123 +5,190 @@ import { dispatchOnControllers, dispatchOnOrCreateControllers } from "./dispatch
 import { wrapEvent } from "./event-wrapper.js";
 
 /** The value delivered to a drop target: a primitive (converted to a GObject.Value) or an explicit GObject.Value. */
-export type DropContent = string | number | boolean | GObject.Value;
+type DropContent = string | number | boolean | GObject.Value;
 
 /** Options for a drop: the drop coordinates within the target. */
-export type DropOptions = {
+type DropOptions = {
     x?: number;
     y?: number;
 };
 
 /** A drag offset relative to the drag start point. */
-export type DragOffset = {
+type DragOffset = {
     x: number;
     y: number;
 };
 
-/** Options for a drag gesture: the starting point, the number of interpolated drag updates, or explicit intermediate offsets emitted before the final one. */
-export type DragOptions = {
+/**
+ * Options for a drag gesture: the starting point, the number of interpolated drag updates, or
+ * explicit intermediate offsets emitted before the final one.
+ */
+type DragOptions = {
     startX?: number;
     startY?: number;
     steps?: number;
     offsets?: DragOffset[];
 };
 
+type DragInstancePatch = {
+    getStartPoint?: Gtk.GestureDrag["getStartPoint"] | undefined;
+    getOffset?: Gtk.GestureDrag["getOffset"] | undefined;
+};
+
+type SavedDragState = {
+    instance: DragInstancePatch;
+    ownsStartPoint: boolean;
+    ownsOffset: boolean;
+    previousStartPoint: DragInstancePatch["getStartPoint"];
+    previousOffset: DragInstancePatch["getOffset"];
+};
+
 const buildDropValue = (content: DropContent): GObject.Value => {
-    if (content instanceof GObject.Value) return content;
+    if (content instanceof GObject.Value) {
+        return content;
+    }
+
     if (typeof content === "string") {
-        return GObject.buildValue(GObject.TYPE_STRING, (v) => v.setString(content));
+        return GObject.buildValue(GObject.TYPE_STRING, (v) => {
+            v.setString(content);
+        });
     }
+
     if (typeof content === "boolean") {
-        return GObject.buildValue(GObject.TYPE_BOOLEAN, (v) => v.setBoolean(content));
+        return GObject.buildValue(GObject.TYPE_BOOLEAN, (v) => {
+            v.setBoolean(content);
+        });
     }
-    return GObject.buildValue(GObject.TYPE_DOUBLE, (v) => v.setDouble(content));
+
+    return GObject.buildValue(GObject.TYPE_DOUBLE, (v) => {
+        v.setDouble(content);
+    });
 };
 
-export const hover = (widget: Gtk.Widget): Promise<void> =>
-    dispatchOnOrCreateControllers(widget, Gtk.EventControllerMotion, (controller) => controller.emit("enter", 0, 0));
+const hover = (widget: Gtk.Widget): Promise<void> =>
+    dispatchOnOrCreateControllers(widget, Gtk.EventControllerMotion, (controller) => {
+        controller.emit("enter", 0, 0);
+    });
 
-export const unhover = (widget: Gtk.Widget): Promise<void> =>
-    dispatchOnOrCreateControllers(widget, Gtk.EventControllerMotion, (controller) => controller.emit("leave"));
+const unhover = (widget: Gtk.Widget): Promise<void> =>
+    dispatchOnOrCreateControllers(widget, Gtk.EventControllerMotion, (controller) => {
+        controller.emit("leave");
+    });
 
-export const rotate = (widget: Gtk.Widget, angle: number, deltaAngle: number = angle): Promise<void> =>
-    dispatchOnControllers(widget, Gtk.GestureRotate, (controller) =>
-        controller.emit("angle-changed", angle, deltaAngle),
+const rotate = (widget: Gtk.Widget, angle: number, deltaAngle: number = angle): Promise<void> =>
+    dispatchOnControllers(widget, Gtk.GestureRotate, (controller) => {
+        controller.emit("angle-changed", angle, deltaAngle);
+    },
     );
 
-export const zoom = (widget: Gtk.Widget, scale: number): Promise<void> =>
-    dispatchOnControllers(widget, Gtk.GestureZoom, (controller) => controller.emit("scale-changed", scale));
+const zoom = (widget: Gtk.Widget, scale: number): Promise<void> =>
+    dispatchOnControllers(widget, Gtk.GestureZoom, (controller) => {
+        controller.emit("scale-changed", scale);
+    });
 
-export const swipe = (widget: Gtk.Widget, velocityX: number, velocityY: number): Promise<void> =>
-    dispatchOnControllers(widget, Gtk.GestureSwipe, (controller) => controller.emit("swipe", velocityX, velocityY));
+const swipe = (widget: Gtk.Widget, velocityX: number, velocityY: number): Promise<void> =>
+    dispatchOnControllers(widget, Gtk.GestureSwipe, (controller) => {
+        controller.emit("swipe", velocityX, velocityY);
+    });
 
-export const longPress = (widget: Gtk.Widget, x: number = 0, y: number = 0): Promise<void> =>
-    dispatchOnControllers(widget, Gtk.GestureLongPress, (controller) => controller.emit("pressed", x, y));
+const longPress = (widget: Gtk.Widget, x = 0, y = 0): Promise<void> =>
+    dispatchOnControllers(widget, Gtk.GestureLongPress, (controller) => {
+        controller.emit("pressed", x, y);
+    });
 
-type DragInstancePatch = {
-    getStartPoint?: Gtk.GestureDrag["getStartPoint"] | undefined;
-    getOffset?: Gtk.GestureDrag["getOffset"] | undefined;
+const restoreDragState = (saved: SavedDragState): void => {
+    const { instance } = saved;
+
+    if (saved.ownsStartPoint) {
+        instance.getStartPoint = saved.previousStartPoint;
+    } else {
+        delete instance.getStartPoint;
+    }
+
+    if (saved.ownsOffset) {
+        instance.getOffset = saved.previousOffset;
+    } else {
+        delete instance.getOffset;
+    }
 };
 
 const patchDragState = (controller: Gtk.GestureDrag, start: DragOffset, offset: () => DragOffset): (() => void) => {
     const instance: DragInstancePatch = controller;
-    const ownsStartPoint = Object.hasOwn(instance, "getStartPoint");
-    const ownsOffset = Object.hasOwn(instance, "getOffset");
-    const previousStartPoint = instance.getStartPoint;
-    const previousOffset = instance.getOffset;
+
+    const saved: SavedDragState = {
+        instance,
+        ownsStartPoint: Object.hasOwn(instance, "getStartPoint"),
+        ownsOffset: Object.hasOwn(instance, "getOffset"),
+        previousStartPoint: instance.getStartPoint,
+        previousOffset: instance.getOffset,
+    };
+
     instance.getStartPoint = () => [true, start.x, start.y];
+
     instance.getOffset = () => {
         const current = offset();
+
         return [true, current.x, current.y];
     };
+
     return () => {
-        if (ownsStartPoint) instance.getStartPoint = previousStartPoint;
-        else delete instance.getStartPoint;
-        if (ownsOffset) instance.getOffset = previousOffset;
-        else delete instance.getOffset;
+        restoreDragState(saved);
     };
 };
 
+const emitToControllers = (controllers: Gtk.GestureDrag[], signal: string, x: number, y: number): void => {
+    for (const controller of controllers) {
+        controller.emit(signal, x, y);
+    }
+};
+
 const runDragSequence = (controllers: Gtk.GestureDrag[], start: DragOffset, updates: DragOffset[]): void => {
     let current: DragOffset = { x: 0, y: 0 };
     const restores = controllers.map((controller) => patchDragState(controller, start, () => current));
+
     try {
-        for (const controller of controllers) {
-            controller.emit("drag-begin", start.x, start.y);
-        }
+        emitToControllers(controllers, "drag-begin", start.x, start.y);
+
         for (const update of updates) {
             current = update;
-            for (const controller of controllers) {
-                controller.emit("drag-update", update.x, update.y);
-            }
-        }
-        for (const controller of controllers) {
-            controller.emit("drag-end", current.x, current.y);
+            emitToControllers(controllers, "drag-update", update.x, update.y);
         }
+
+        emitToControllers(controllers, "drag-end", current.x, current.y);
     } finally {
-        for (const restore of restores) restore();
+        for (const restore of restores) {
+            restore();
+        }
     }
 };
 
 const resolveDragUpdates = (dx: number, dy: number, options: DragOptions): DragOffset[] => {
-    if (options.offsets) return [...options.offsets, { x: dx, y: dy }];
+    if (options.offsets) {
+        return [...options.offsets, { x: dx, y: dy }];
+    }
+
     const steps = Math.max(1, Math.floor(options.steps ?? 2));
     const updates: DragOffset[] = [];
+
     for (let i = 1; i <= steps; i++) {
         updates.push({ x: (dx * i) / steps, y: (dy * i) / steps });
     }
+
     return updates;
 };
 
-export const drag = async (widget: Gtk.Widget, dx: number, dy: number, options: DragOptions = {}): Promise<void> => {
+const drag = async (widget: Gtk.Widget, dx: number, dy: number, options: DragOptions = {}): Promise<void> => {
     if (widget instanceof Gtk.Range) {
-        throw new Error(
-            "userEvent.drag cannot drive a Gtk.Range's built-in slider (its drag reads pointer coordinates from the display); " +
-                "use userEvent.slide(range, value) or userEvent.keyboard for sliders",
+        throw new TypeError(
+            "userEvent.drag cannot drive a Gtk.Range's built-in slider " +
+            "(its drag reads pointer coordinates from the display); " +
+            "use userEvent.slide(range, value) or userEvent.keyboard for sliders",
         );
     }
+
     const start = { x: options.startX ?? 0, y: options.startY ?? 0 };
     const updates = resolveDragUpdates(dx, dy, options);
+
     await wrapEvent(widget, () => {
         runDragSequence(getAllControllers(widget, Gtk.GestureDrag), start, updates);
     });
@@ -129,17 +196,18 @@ export const drag = async (widget: Gtk.Widget, dx: number, dy: number, options:
 
 const emitDrop = (target: Gtk.Widget, content: DropContent, options: DropOptions): void => {
     const dropTargets = getAllControllers(target, Gtk.DropTarget);
+
     for (const dropTarget of dropTargets) {
         dropTarget.emit("drop", buildDropValue(content), options.x ?? 0, options.y ?? 0);
     }
 };
 
-export const drop = (widget: Gtk.Widget, content: DropContent, options: DropOptions = {}): Promise<void> =>
+const drop = (widget: Gtk.Widget, content: DropContent, options: DropOptions = {}): Promise<void> =>
     wrapEvent(widget, () => {
         emitDrop(widget, content, options);
     });
 
-export const dragAndDrop = async (
+const dragAndDrop = async (
     source: Gtk.Widget,
     target: Gtk.Widget,
     content: DropContent,
@@ -148,7 +216,24 @@ export const dragAndDrop = async (
     await wrapEvent(source, () => {
         getAllControllers(source, Gtk.DragSource);
     });
+
     await wrapEvent(target, () => {
         emitDrop(target, content, options);
     });
 };
+
+export {
+    hover,
+    unhover,
+    rotate,
+    zoom,
+    swipe,
+    longPress,
+    drag,
+    drop,
+    dragAndDrop,
+    type DropContent,
+    type DropOptions,
+    type DragOffset,
+    type DragOptions,
+};

package/src/user-event/index.ts

@@ -3,20 +3,16 @@ 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 { keyboard, tab } from "./keyboard.js";
-import { type PointerInput, pointer } from "./pointer.js";
+import { pointer, type PointerInput } from "./pointer.js";
 import { deselectOptions, selectOptions } from "./selection.js";
 import { createInitialState } from "./state.js";
 import { clear, copy, cut, paste, type } from "./text.js";
 
-export type { ScrollDelta } from "./adjustment.js";
-export type { DragOffset, DragOptions, DropContent, DropOptions } from "./gesture.js";
-export type { TabOptions } from "./keyboard.js";
-export type { PointerInput } from "./pointer.js";
-export type { TypeOptions } from "./text.js";
-export { resetClipboard } from "./text.js";
-
-/** The set of user interaction helpers exposed by {@link userEvent}, covering clicks, typing, keyboard, pointer, gestures, selection, and scrolling. */
-export type UserEvent = {
+/**
+ * The set of user interaction helpers exposed by {@link userEvent}, covering clicks, typing,
+ * keyboard, pointer, gestures, selection, and scrolling.
+ */
+type UserEvent = {
     click: typeof click;
     dblClick: typeof dblClick;
     tripleClick: typeof tripleClick;
@@ -45,8 +41,11 @@ export type UserEvent = {
 
 const state = createInitialState();
 
-/** High-level helpers that drive widgets by dispatching the same events and gestures GTK4 delivers when someone clicks, types, or drags. */
-export const userEvent: UserEvent = {
+/**
+ * High-level helpers that drive widgets by dispatching the same events and gestures GTK4 delivers
+ * when someone clicks, types, or drags.
+ */
+const userEvent: UserEvent = {
     click,
     dblClick,
     tripleClick,
@@ -72,3 +71,11 @@ export const userEvent: UserEvent = {
     keyboard: (widget: Gtk.Widget, input: string): Promise<void> => keyboard(state, widget, input),
     pointer: (widget: Gtk.Widget, input: PointerInput): Promise<void> => pointer(state, widget, input),
 };
+
+export type { ScrollDelta } from "./adjustment.js";
+export type { DragOffset, DragOptions, DropContent, DropOptions } from "./gesture.js";
+export type { TabOptions } from "./keyboard.js";
+export type { PointerInput } from "./pointer.js";
+export type { TypeOptions } from "./text.js";
+export { resetClipboard } from "./text.js";
+export { userEvent, type UserEvent };