@gtkx/testing 1.6.0 → 2.0.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/testing",
-  "version": "1.6.0",
+  "version": "2.0.0-beta.2",
   "description": "Queries, events, and screenshots for GTK and GTK4 widget trees.",
   "keywords": [
     "gtkx",
@@ -29,10 +29,14 @@
     "./package.json": "./package.json",
     ".": {
       "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": null,
       "default": "./dist/index.js"
     },
     "./internal": {
       "types": "./dist/internal.d.ts",
+      "import": "./dist/internal.js",
+      "require": null,
       "default": "./dist/internal.js"
     }
   },
@@ -55,22 +59,22 @@
     }
   },
   "engines": {
-    "node": ">=24"
+    "node": ">=26.7.0"
   },
   "dependencies": {
+    "@gtkx/runtime": "2.0.0-beta.2",
+    "@gtkx/react": "2.0.0-beta.2",
+    "@gtkx/utils": "2.0.0-beta.2",
     "@vitest/expect": "^4.1.11",
-    "@vitest/pretty-format": "^4.1.11",
-    "@gtkx/react": "1.6.0",
-    "@gtkx/utils": "1.6.0",
-    "@gtkx/runtime": "1.6.0"
+    "@vitest/pretty-format": "^4.1.11"
   },
   "peerDependencies": {
     "@types/react": "^19.2",
     "react": "^19.2"
   },
   "devDependencies": {
-    "@types/react": "^19.2.18",
-    "@gtkx/config": "1.6.0"
+    "@gtkx/config": "2.0.0-beta.2",
+    "@types/react": "^19.2.18"
   },
   "scripts": {
     "release": "tsx ../../scripts/release-package.ts"

package/src/config.ts

@@ -50,9 +50,7 @@ function defaultGetElementError(message: string): Error {
 /**
  * Returns the current global testing configuration.
  */
-const getConfig = (): Config => {
-    return currentConfig;
-};
+const getConfig = (): Config => currentConfig;
 
 /**
  * Merges the given overrides into the global testing configuration.

package/src/fire-event.ts

@@ -31,7 +31,7 @@ const createEvent = (target: GObject.Object, signalName: string, ...args: unknow
 
 const dispatchEvent = async (event: WidgetEvent): Promise<void> => {
     await runInAct(() => {
-        event.target.emit(event.signalName, ...event.args);
+        Reflect.apply(GObject.signalEmit, undefined, [event.target, event.signalName, ...event.args]);
     });
 };
 

package/src/matchers.ts

@@ -525,9 +525,6 @@ const isAppearingBefore = (first: Gtk.Widget, second: Gtk.Widget): boolean => {
     return isSeparateWidget(first, second) && root === getTreeRoot(second) && isPrecedingWidget(root, first, second);
 };
 
-const camelCase = (name: string): string =>
-    name.replaceAll(/-([a-z])/g, (_match, letter: string) => letter.toUpperCase());
-
 const isAsymmetricMatcher = (value: unknown): boolean =>
     typeof value === "object" && value !== null && typeof Reflect.get(value, "asymmetricMatch") === "function";
 
@@ -588,26 +585,8 @@ function readErrorMessageText(widget: Gtk.Widget): string | null {
     return texts.length > 0 ? texts.join(" ") : null;
 }
 
-function assertReadableProperty(object: GObject.Object, name: string, property: string, value: unknown): void {
-    if (typeof value === "function") {
-        throw new TypeError(
-            `toHaveObjectProperty: "${name}" is shadowed by a method of the same name; ` +
-            `call ${property}() and assert on its result instead`,
-        );
-    }
-
-    if (value === undefined && !Reflect.has(object, property)) {
-        throw new TypeError(
-            `toHaveObjectProperty: no readable property "${name}" on ${describeObject(object)}; ` +
-            "construct-only and write-only properties cannot be read back",
-        );
-    }
-}
-
 function readObjectProperty(object: GObject.Object, name: string): unknown {
-    const property = camelCase(name);
-    const value: unknown = Reflect.get(object, property);
-    assertReadableProperty(object, name, property, value);
+    const value: unknown = Reflect.apply(GObject.getObjectProperty, undefined, [object, name]);
 
     return value;
 }

package/src/queries.ts

@@ -106,161 +106,65 @@ const builtinQueries = {
     ...displayValueQueries,
 } as BuiltinQueries;
 
-/**
- * Returns the single mapped widget with a matching accessible role and options, or null when none
- * match. Widgets that are not mapped are never matched. Throws when more than one matches.
- */
+/** Queries one mapped widget by accessible role. */
 const queryByRole: BuiltinQueries["queryByRole"] = builtinQueries.queryByRole;
-/**
- * Returns every mapped widget with a matching accessible role and options. Widgets that are not
- * mapped are never matched. Throws when none match.
- */
+/** Gets all mapped widgets with an accessible role. */
 const getAllByRole: BuiltinQueries["getAllByRole"] = builtinQueries.getAllByRole;
-/**
- * Returns the single mapped widget with a matching accessible role and options. Widgets that are not
- * mapped are never matched. Throws when none or more than one matches.
- */
+/** Gets one mapped widget by accessible role. */
 const getByRole: BuiltinQueries["getByRole"] = builtinQueries.getByRole;
-/**
- * Waits for and returns every mapped widget with a matching accessible role and options, retrying
- * until at least one appears or the timeout elapses. Widgets that are not mapped are never matched.
- */
+/** Finds all mapped widgets with an accessible role. */
 const findAllByRole: BuiltinQueries["findAllByRole"] = builtinQueries.findAllByRole;
-/**
- * Waits for and returns the single mapped widget with a matching accessible role and options,
- * retrying until it appears or the timeout elapses. Widgets that are not mapped are never matched.
- * Rejects when none or more than one matches.
- */
+/** Finds one mapped widget by accessible role. */
 const findByRole: BuiltinQueries["findByRole"] = builtinQueries.findByRole;
-/**
- * Returns the single mapped widget with matching associated label text, or null when none match.
- * Widgets that are not mapped are never matched. Throws when more than one matches.
- */
+/** Queries one mapped widget by label text. */
 const queryByLabelText: BuiltinQueries["queryByLabelText"] = builtinQueries.queryByLabelText;
-/**
- * Returns every mapped widget with matching associated label text. Widgets that are not mapped are
- * never matched. Throws when none match.
- */
+/** Gets all mapped widgets with label text. */
 const getAllByLabelText: BuiltinQueries["getAllByLabelText"] = builtinQueries.getAllByLabelText;
-/**
- * Returns the single mapped widget with matching associated label text. Widgets that are not mapped
- * are never matched. Throws when none or more than one matches.
- */
+/** Gets one mapped widget by label text. */
 const getByLabelText: BuiltinQueries["getByLabelText"] = builtinQueries.getByLabelText;
-/**
- * Waits for and returns every mapped widget with matching associated label text, retrying until at
- * least one appears or the timeout elapses. Widgets that are not mapped are never matched.
- */
+/** Finds all mapped widgets with label text. */
 const findAllByLabelText: BuiltinQueries["findAllByLabelText"] = builtinQueries.findAllByLabelText;
-/**
- * Waits for and returns the single mapped widget with matching associated label text, retrying until
- * it appears or the timeout elapses. Widgets that are not mapped are never matched. Rejects when
- * none or more than one matches.
- */
+/** Finds one mapped widget by label text. */
 const findByLabelText: BuiltinQueries["findByLabelText"] = builtinQueries.findByLabelText;
-/**
- * Returns the single mapped widget with matching rendered text content, or null when none match.
- * Widgets that are not mapped are never matched. Throws when more than one matches.
- */
+/** Queries one mapped widget by rendered text. */
 const queryByText: BuiltinQueries["queryByText"] = builtinQueries.queryByText;
-/**
- * Returns every mapped widget with matching rendered text content. Widgets that are not mapped are
- * never matched. Throws when none match.
- */
+/** Gets all mapped widgets with rendered text. */
 const getAllByText: BuiltinQueries["getAllByText"] = builtinQueries.getAllByText;
-/**
- * Returns the single mapped widget with matching rendered text content. Widgets that are not mapped
- * are never matched. Throws when none or more than one matches.
- */
+/** Gets one mapped widget by rendered text. */
 const getByText: BuiltinQueries["getByText"] = builtinQueries.getByText;
-/**
- * Waits for and returns every mapped widget with matching rendered text content, retrying until at
- * least one appears or the timeout elapses. Widgets that are not mapped are never matched.
- */
+/** Finds all mapped widgets with rendered text. */
 const findAllByText: BuiltinQueries["findAllByText"] = builtinQueries.findAllByText;
-/**
- * Waits for and returns the single mapped widget with matching rendered text content, retrying until
- * it appears or the timeout elapses. Widgets that are not mapped are never matched. Rejects when
- * none or more than one matches.
- */
+/** Finds one mapped widget by rendered text. */
 const findByText: BuiltinQueries["findByText"] = builtinQueries.findByText;
-/**
- * Returns the single mapped widget with a matching widget name, or null when none match. Widgets
- * that are not mapped are never matched. Throws when more than one matches.
- */
+/** Queries one mapped widget by GTK name. */
 const queryByName: BuiltinQueries["queryByName"] = builtinQueries.queryByName;
-/**
- * Returns every mapped widget with a matching widget name. Widgets that are not mapped are never
- * matched. Throws when none match.
- */
+/** Gets all mapped widgets with a GTK name. */
 const getAllByName: BuiltinQueries["getAllByName"] = builtinQueries.getAllByName;
-/**
- * Returns the single mapped widget with a matching widget name. Widgets that are not mapped are
- * never matched. Throws when none or more than one matches.
- */
+/** Gets one mapped widget by GTK name. */
 const getByName: BuiltinQueries["getByName"] = builtinQueries.getByName;
-/**
- * Waits for and returns every mapped widget with a matching widget name, retrying until at least one
- * appears or the timeout elapses. Widgets that are not mapped are never matched.
- */
+/** Finds all mapped widgets with a GTK name. */
 const findAllByName: BuiltinQueries["findAllByName"] = builtinQueries.findAllByName;
-/**
- * Waits for and returns the single mapped widget with a matching widget name, retrying until it
- * appears or the timeout elapses. Widgets that are not mapped are never matched. Rejects when none
- * or more than one matches.
- */
+/** Finds one mapped widget by GTK name. */
 const findByName: BuiltinQueries["findByName"] = builtinQueries.findByName;
-/**
- * Returns the single mapped widget with matching placeholder text, or null when none match. Widgets
- * that are not mapped are never matched. Throws when more than one matches.
- */
+/** Queries one mapped widget by placeholder text. */
 const queryByPlaceholderText: BuiltinQueries["queryByPlaceholderText"] = builtinQueries.queryByPlaceholderText;
-/**
- * Returns every mapped widget with matching placeholder text. Widgets that are not mapped are never
- * matched. Throws when none match.
- */
+/** Gets all mapped widgets with placeholder text. */
 const getAllByPlaceholderText: BuiltinQueries["getAllByPlaceholderText"] = builtinQueries.getAllByPlaceholderText;
-/**
- * Returns the single mapped widget with matching placeholder text. Widgets that are not mapped are
- * never matched. Throws when none or more than one matches.
- */
+/** Gets one mapped widget by placeholder text. */
 const getByPlaceholderText: BuiltinQueries["getByPlaceholderText"] = builtinQueries.getByPlaceholderText;
-/**
- * Waits for and returns every mapped widget with matching placeholder text, retrying until at least
- * one appears or the timeout elapses. Widgets that are not mapped are never matched.
- */
+/** Finds all mapped widgets with placeholder text. */
 const findAllByPlaceholderText: BuiltinQueries["findAllByPlaceholderText"] = builtinQueries.findAllByPlaceholderText;
-/**
- * Waits for and returns the single mapped widget with matching placeholder text, retrying until it
- * appears or the timeout elapses. Widgets that are not mapped are never matched. Rejects when none
- * or more than one matches.
- */
+/** Finds one mapped widget by placeholder text. */
 const findByPlaceholderText: BuiltinQueries["findByPlaceholderText"] = builtinQueries.findByPlaceholderText;
-/**
- * Returns the single mapped widget with a matching display value, or null when none match. Widgets
- * that are not mapped are never matched. Throws when more than one matches.
- */
+/** Queries one mapped widget by display value. */
 const queryByDisplayValue: BuiltinQueries["queryByDisplayValue"] = builtinQueries.queryByDisplayValue;
-/**
- * Returns every mapped widget with a matching display value. Widgets that are not mapped are never
- * matched. Throws when none match.
- */
+/** Gets all mapped widgets with a display value. */
 const getAllByDisplayValue: BuiltinQueries["getAllByDisplayValue"] = builtinQueries.getAllByDisplayValue;
-/**
- * Returns the single mapped widget with a matching display value. Widgets that are not mapped are
- * never matched. Throws when none or more than one matches.
- */
+/** Gets one mapped widget by display value. */
 const getByDisplayValue: BuiltinQueries["getByDisplayValue"] = builtinQueries.getByDisplayValue;
-/**
- * Waits for and returns every mapped widget with a matching display value, retrying until at least
- * one appears or the timeout elapses. Widgets that are not mapped are never matched.
- */
+/** Finds all mapped widgets with a display value. */
 const findAllByDisplayValue: BuiltinQueries["findAllByDisplayValue"] = builtinQueries.findAllByDisplayValue;
-/**
- * Waits for and returns the single mapped widget with a matching display value, retrying until it
- * appears or the timeout elapses. Widgets that are not mapped are never matched. Rejects when none
- * or more than one matches.
- */
+/** Finds one mapped widget by display value. */
 const findByDisplayValue: BuiltinQueries["findByDisplayValue"] = builtinQueries.findByDisplayValue;
 
 const buildNormalizer = (options?: MatcherOptions): NormalizerFn => {

package/src/query-helpers.ts

@@ -1,5 +1,5 @@
 import type * as Gtk from "@gtkx/gi/gtk";
-import { camelCase } from "@gtkx/utils";
+import { getObjectProperty } from "@gtkx/gi/gobject";
 import type { Matcher, MatcherOptions } from "./types.js";
 import { buildQueries } from "./build-queries.js";
 import { getElementError } from "./errors.js";
@@ -27,7 +27,13 @@ const queryHelpers: QueryHelpers = {
 };
 
 const readObjectProperty = (widget: Gtk.Widget, property: string): string | null => {
-    const value: unknown = Reflect.get(widget, camelCase(property));
+    let value: unknown;
+
+    try {
+        value = Reflect.apply(getObjectProperty, undefined, [widget, property]);
+    } catch {
+        return null;
+    }
 
     if (typeof value === "string") {
         return value;

package/src/screenshot.ts

@@ -47,9 +47,7 @@ const OTHER_FAILURE_HINT =
 
 const NOTHING_ON_SCREEN_MESSAGE = "Nothing is on screen to capture: no toplevel window is mapped";
 
-const bytesToBase64 = (bytes: Uint8Array | number[]): string => {
-    return Buffer.from(bytes).toString("base64");
-};
+const bytesToBase64 = (bytes: Uint8Array | number[]): string => Buffer.from(bytes).toString("base64");
 
 const describeWidgetState = (widget: Gtk.Widget): string =>
     `realized=${String(widget.getRealized())} mapped=${String(widget.getMapped())} ` +

package/src/user-event/adjustment.ts

@@ -16,11 +16,7 @@ type ScrollAdjustments = {
     vertical: Gtk.Adjustment | null;
 };
 
-/**
- * Emits a jump `change-value` so a Gtk.Range moves to the given value.
- *
- * @throws When the widget is not a Gtk.Range.
- */
+/** Moves a range to a value. */
 const slide = (widget: Gtk.Widget, value: number): Promise<void> =>
     wrapEvent(widget, () => {
         if (!(widget instanceof Gtk.Range)) {
@@ -76,15 +72,7 @@ const applyScrollDelta = (adjustment: Gtk.Adjustment | null, delta: number): voi
     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.
- */
+/** Scrolls the widget or its nearest scrollable ancestor. */
 const scroll = (widget: Gtk.Widget, delta: ScrollDelta): Promise<void> =>
     wrapEvent(widget, async () => {
         const adjustments = resolveScrollAdjustments(widget);

package/src/user-event/click.ts

@@ -205,7 +205,7 @@ const applyContainerOutcome = (target: ClickTarget, nPress: number): void => {
     }
 
     if (isActivatedByClick(container, nPress)) {
-        widget.activate();
+        Gtk.Widget.prototype.activate.call(widget);
     }
 
     if (isSelectionReplacedByClick(container, nPress)) {
@@ -246,39 +246,13 @@ const tryActivate = async (widget: Gtk.Widget): Promise<boolean> => {
     let isActivated = false;
 
     await wrapEvent(widget, () => {
-        isActivated = widget.activate();
+        isActivated = Gtk.Widget.prototype.activate.call(widget);
     });
 
     return isActivated;
 };
 
-/**
- * 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 notebook tab, clicked directly or through its label,
- * focuses its notebook and switches to its page; 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.
- */
+/** Activates or presses and releases a widget. */
 const click = async (widget: Gtk.Widget): Promise<void> => {
     if (!isSelfClickTarget(widget) && (await tryActivate(widget))) {
         return;
@@ -287,21 +261,9 @@ const click = async (widget: Gtk.Widget): Promise<void> => {
     await deliverClick(widget, 1);
 };
 
-/**
- * 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, a notebook tab stays on
- * the page the first press opened, and a column header sorts and then inverts its order.
- */
+/** Delivers a double-click gesture. */
 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, notebook tab, or column header.
- */
+/** Delivers a triple-click gesture. */
 const tripleClick = (widget: Gtk.Widget): Promise<void> => deliverClick(widget, 3);
 
 export { clickGestures, emitClickPhase, getAuthoredClickGestures, click, dblClick, tripleClick };

package/src/user-event/gesture.ts

@@ -83,56 +83,38 @@ const buildDropValue = (content: DropContent): GObject.Value => {
     });
 };
 
-/** Emits `enter` at the widget's origin on its motion controllers, adding one when it has none. */
+/** Enters a widget. */
 const hover = (widget: Gtk.Widget): Promise<void> =>
     dispatchOnOrCreateControllers(widget, Gtk.EventControllerMotion, (controller) => {
         controller.emit("enter", 0, 0);
     });
 
-/** Emits `leave` on the widget's motion controllers, adding one when it has none. */
+/** Leaves a widget. */
 const unhover = (widget: Gtk.Widget): Promise<void> =>
     dispatchOnOrCreateControllers(widget, Gtk.EventControllerMotion, (controller) => {
         controller.emit("leave");
     });
 
-/**
- * Emits `angle-changed` on the widget's rotate gestures.
- *
- * @param angle Current angle, in radians.
- * @param deltaAngle Difference from the angle the gesture started at; defaults to `angle`.
- * @throws When the widget has no Gtk.GestureRotate.
- */
+/** Rotates a widget's gestures. */
 const rotate = (widget: Gtk.Widget, angle: number, deltaAngle: number = angle): Promise<void> =>
     dispatchOnControllers(widget, Gtk.GestureRotate, (controller) => {
         controller.emit("angle-changed", angle, deltaAngle);
     },
     );
 
-/**
- * Emits `scale-changed` with the given scale delta on the widget's zoom gestures.
- *
- * @throws When the widget has no Gtk.GestureZoom.
- */
+/** Zooms a widget's gestures. */
 const zoom = (widget: Gtk.Widget, scale: number): Promise<void> =>
     dispatchOnControllers(widget, Gtk.GestureZoom, (controller) => {
         controller.emit("scale-changed", scale);
     });
 
-/**
- * Emits `swipe` with the given per-axis velocity, in pixels per second, on the widget's swipe gestures.
- *
- * @throws When the widget has no Gtk.GestureSwipe.
- */
+/** Swipes a widget's gestures. */
 const swipe = (widget: Gtk.Widget, velocityX: number, velocityY: number): Promise<void> =>
     dispatchOnControllers(widget, Gtk.GestureSwipe, (controller) => {
         controller.emit("swipe", velocityX, velocityY);
     });
 
-/**
- * Emits `pressed` at the given point in widget coordinates on the widget's long-press gestures.
- *
- * @throws When the widget has no Gtk.GestureLongPress.
- */
+/** Long-presses a widget. */
 const longPress = (widget: Gtk.Widget, x = 0, y = 0): Promise<void> =>
     dispatchOnControllers(widget, Gtk.GestureLongPress, (controller) => {
         controller.emit("pressed", x, y);
@@ -219,14 +201,7 @@ const resolveDragUpdates = (dx: number, dy: number, options: DragOptions): DragO
     return updates;
 };
 
-/**
- * Runs a `drag-begin`, `drag-update`, `drag-end` sequence ending at the offset `dx`, `dy` on the
- * widget's drag gestures, overriding each gesture's start point and offset for the duration so
- * handlers read the simulated values back.
- *
- * @throws When the widget is a Gtk.Range, whose slider reads pointer coordinates from the display,
- * or when it has no Gtk.GestureDrag.
- */
+/** Drags a widget by an offset. */
 const drag = async (widget: Gtk.Widget, dx: number, dy: number, options: DragOptions = {}): Promise<void> => {
     if (widget instanceof Gtk.Range) {
         throw new TypeError(
@@ -252,22 +227,13 @@ const emitDrop = (target: Gtk.Widget, content: DropContent, options: DropOptions
     }
 };
 
-/**
- * Emits `drop` with the given content on every drop target attached to the widget.
- *
- * @throws When the widget has no Gtk.DropTarget.
- */
+/** Drops content on a widget. */
 const drop = (widget: Gtk.Widget, content: DropContent, options: DropOptions = {}): Promise<void> =>
     wrapEvent(widget, () => {
         emitDrop(widget, content, options);
     });
 
-/**
- * Emits `drop` with the given content on the target's drop targets, after checking that the source
- * carries a drag source.
- *
- * @throws When the source has no Gtk.DragSource, or the target no Gtk.DropTarget.
- */
+/** Drags content from one widget and drops it on another. */
 const dragAndDrop = async (
     source: Gtk.Widget,
     target: Gtk.Widget,