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

package/src/user-event/text.ts

@@ -6,7 +6,7 @@ import { formatRoleList } from "../role-helpers.js";
 import { wrapEvent } from "./event-wrapper.js";
 
 /** Options for {@link type}. */
-export type TypeOptions = {
+type TypeOptions = {
     /** Do not focus the widget before typing. */
     skipClick?: boolean | undefined;
     /** Select from this offset before typing, replacing the selected range with the typed text. */
@@ -20,11 +20,15 @@ const EDITABLE_REQUIRED = `expected editable widget (${formatRoleList(EDITABLE_R
 const insertEditableText = (widget: EditableTarget, text: string): void => {
     if (widget instanceof Gtk.TextView) {
         widget.emit("insert-at-cursor", text);
+
         return;
     }
+
     const target = getEditableDelegate(widget) ?? widget;
+
     if (target instanceof Gtk.Text) {
         target.emit("insert-at-cursor", text);
+
         return;
     }
 
@@ -37,101 +41,132 @@ const readSelection = (widget: EditableTarget): string => {
     if (widget instanceof Gtk.TextView) {
         const buffer = widget.getBuffer();
         const [hasSelection, start, end] = buffer.getSelectionBounds();
+
         return hasSelection ? buffer.getText(start, end, true) : "";
     }
+
     const [hasSelection, start, end] = widget.getSelectionBounds();
+
     return hasSelection ? widget.getChars(start, end) : "";
 };
 
 const deleteSelection = (widget: EditableTarget): void => {
     if (widget instanceof Gtk.TextView) {
         widget.getBuffer().deleteSelection(false, true);
+
         return;
     }
+
     widget.deleteSelection();
 };
 
 const setEditableText = (widget: EditableTarget, text: string): void => {
     if (widget instanceof Gtk.TextView) {
         widget.getBuffer().setText(text, text.length);
+
         return;
     }
+
     widget.setText(text);
 };
 
+const applyTextViewSelection = (widget: Gtk.TextView, start: number, end: number): void => {
+    const buffer = widget.getBuffer();
+    buffer.selectRange(buffer.getIterAtOffset(start), buffer.getIterAtOffset(end));
+
+    if (end !== start) {
+        deleteSelection(widget);
+    }
+};
+
+const applyEditableSelection = (widget: Gtk.Editable, start: number, end: number): void => {
+    widget.selectRegion(start, end);
+
+    if (end !== start) {
+        widget.deleteSelection();
+    }
+
+    widget.setPosition(start);
+};
+
 const applyInitialSelection = (widget: EditableTarget, options: TypeOptions): void => {
-    if (options.initialSelectionStart === undefined) return;
+    if (options.initialSelectionStart === undefined) {
+        return;
+    }
+
     const start = options.initialSelectionStart;
     const end = options.initialSelectionEnd ?? start;
+
     if (widget instanceof Gtk.TextView) {
-        const buffer = widget.getBuffer();
-        buffer.selectRange(buffer.getIterAtOffset(start), buffer.getIterAtOffset(end));
-        if (end !== start) deleteSelection(widget);
+        applyTextViewSelection(widget, start, end);
+
         return;
     }
-    widget.selectRegion(start, end);
-    if (end !== start) widget.deleteSelection();
-    widget.setPosition(start);
+
+    applyEditableSelection(widget, start, end);
 };
 
 const writeClipboardText = (widget: Gtk.Widget, text: string): void => {
-    const value = GObject.buildValue(GObject.TYPE_STRING, (v) => v.setString(text));
+    const value = GObject.buildValue(GObject.TYPE_STRING, (v) => {
+        v.setString(text);
+    });
+
     widget.getClipboard().set(value);
 };
 
-export const resetClipboard = (): void => {
+const resetClipboard = (): void => {
     Gdk.Display.getDefault()?.getClipboard().setContent(null);
 };
 
-export const type = (widget: Gtk.Widget, text: string, options?: TypeOptions): Promise<void> =>
+const runEditableEvent = (
+    widget: Gtk.Widget,
+    failure: string,
+    action: (editable: EditableTarget) => void,
+): Promise<void> =>
     wrapEvent(widget, () => {
         if (!isEditable(widget)) {
-            throw new Error(`Cannot type into element: ${EDITABLE_REQUIRED}`);
-        }
-
-        if (!options?.skipClick) {
-            widget.grabFocus();
+            throw new Error(`${failure}: ${EDITABLE_REQUIRED}`);
         }
 
-        applyInitialSelection(widget, options ?? {});
-        insertEditableText(widget, text);
+        action(widget);
     });
 
-export const clear = (widget: Gtk.Widget): Promise<void> =>
-    wrapEvent(widget, () => {
-        if (!isEditable(widget)) {
-            throw new Error(`Cannot clear element: ${EDITABLE_REQUIRED}`);
+const type = (widget: Gtk.Widget, text: string, options?: TypeOptions): Promise<void> =>
+    runEditableEvent(widget, "Cannot type into element", (editable) => {
+        if (!options?.skipClick) {
+            editable.grabFocus();
         }
 
-        setEditableText(widget, "");
+        applyInitialSelection(editable, options ?? {});
+        insertEditableText(editable, text);
     });
 
-export const copy = (widget: Gtk.Widget): Promise<void> =>
-    wrapEvent(widget, () => {
-        if (!isEditable(widget)) {
-            throw new Error(`Cannot copy: ${EDITABLE_REQUIRED}`);
-        }
-
-        writeClipboardText(widget, readSelection(widget));
+const clear = (widget: Gtk.Widget): Promise<void> =>
+    runEditableEvent(widget, "Cannot clear element", (editable) => {
+        setEditableText(editable, "");
     });
 
-export const cut = (widget: Gtk.Widget): Promise<void> =>
-    wrapEvent(widget, () => {
-        if (!isEditable(widget)) {
-            throw new Error(`Cannot cut: ${EDITABLE_REQUIRED}`);
-        }
+const copy = (widget: Gtk.Widget): Promise<void> =>
+    runEditableEvent(widget, "Cannot copy", (editable) => {
+        writeClipboardText(editable, readSelection(editable));
+    });
 
-        writeClipboardText(widget, readSelection(widget));
-        deleteSelection(widget);
+const cut = (widget: Gtk.Widget): Promise<void> =>
+    runEditableEvent(widget, "Cannot cut", (editable) => {
+        writeClipboardText(editable, readSelection(editable));
+        deleteSelection(editable);
     });
 
-export const paste = async (widget: Gtk.Widget, text?: string): Promise<void> => {
+const paste = async (widget: Gtk.Widget, text?: string): Promise<void> => {
     if (!isEditable(widget)) {
         throw new Error(`Cannot paste: ${EDITABLE_REQUIRED}`);
     }
 
     const content = text ?? (await widget.getClipboard().readTextAsync(null)) ?? "";
+
     await wrapEvent(widget, () => {
         insertEditableText(widget, content);
     });
 };
+
+export { resetClipboard, type, clear, copy, cut, paste, type TypeOptions };

package/src/wait-for.ts

@@ -1,17 +1,70 @@
 import type * as Gtk from "@gtkx/gi/gtk";
+import type { WaitForOptions } from "./types.js";
 import { runWithActEnvironment } from "./act.js";
 import { getConfig } from "./config.js";
 import { timeoutError } from "./errors.js";
-import type { WaitForOptions } from "./types.js";
+
+type PollResult<T> = { status: "resolved"; value: T } | { status: "timedout"; lastError: Error | null };
+type RemovalTarget = Gtk.Widget | Gtk.Widget[] | null;
+type ElementOrCallback = Gtk.Widget | Gtk.Widget[] | (() => RemovalTarget);
 
 const DEFAULT_INTERVAL = 50;
+const ELEMENT_NOT_REMOVED = new Error("Element not yet removed");
 
 const delay = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));
 
 const copyStackTrace = (target: Error, source: Error): void => {
-    if (source.stack) {
-        target.stack = source.stack.replace(source.message, target.message);
+    const { stack } = source;
+
+    if (stack === undefined) {
+        return;
     }
+
+    const index = stack.indexOf(source.message);
+
+    if (index === -1) {
+        target.stack = stack;
+
+        return;
+    }
+
+    target.stack = stack.slice(0, index) + target.message + stack.slice(index + source.message.length);
+};
+
+const pollUntilSuccess = async <T>(
+    callback: () => T | Promise<T>,
+    timeout: number,
+    interval: number,
+): Promise<PollResult<T>> => {
+    const startTime = Date.now();
+    let lastError: Error | null = null;
+
+    while (Date.now() - startTime < timeout) {
+        try {
+            const result = await callback();
+            await delay(0);
+
+            return { status: "resolved", value: result };
+        } catch (error) {
+            lastError = error as Error;
+            await delay(interval);
+        }
+    }
+
+    return { status: "timedout", lastError };
+};
+
+const buildTimeoutError = (
+    timeout: number,
+    lastError: Error | null,
+    stackTraceError: Error,
+    onTimeout: ((error: Error) => Error) | undefined,
+): Error => {
+    const error = timeoutError(timeout, lastError);
+    const finalError = onTimeout ? onTimeout(error) : error;
+    copyStackTrace(finalError, stackTraceError);
+
+    return finalError;
 };
 
 /**
@@ -22,7 +75,7 @@ const copyStackTrace = (target: Error, source: Error): void => {
  * @param options Optional timeout, interval, and timeout error customization.
  * @returns The callback's result once it succeeds.
  */
-export const waitFor = <T>(callback: () => T | Promise<T>, options?: WaitForOptions): Promise<T> => {
+const waitFor = <T>(callback: () => T | Promise<T>, options?: WaitForOptions): Promise<T> => {
     if (typeof callback !== "function") {
         throw new TypeError("Received `callback` arg must be a function");
     }
@@ -33,41 +86,24 @@ export const waitFor = <T>(callback: () => T | Promise<T>, options?: WaitForOpti
         runWithActEnvironment(false, async () => {
             const config = getConfig();
             const { timeout = config.asyncUtilTimeout, interval = DEFAULT_INTERVAL, onTimeout } = options ?? {};
-            const startTime = Date.now();
-            let lastError: Error | null = null;
-
-            while (Date.now() - startTime < timeout) {
-                try {
-                    const result = await callback();
-                    await delay(0);
-                    return result;
-                } catch (error) {
-                    lastError = error as Error;
-                    await delay(interval);
-                }
+            const result = await pollUntilSuccess(callback, timeout, interval);
+
+            if (result.status === "resolved") {
+                return result.value;
             }
 
-            const error = timeoutError(timeout, lastError);
-            const finalError = onTimeout ? onTimeout(error) : error;
-            copyStackTrace(finalError, stackTraceError);
-            throw finalError;
+            throw buildTimeoutError(timeout, result.lastError, stackTraceError, onTimeout);
         }),
     );
 };
 
-type RemovalTarget = Gtk.Widget | Gtk.Widget[] | null;
-
-type ElementOrCallback = Gtk.Widget | Gtk.Widget[] | (() => RemovalTarget);
-
-const getTarget = (elementOrCallback: ElementOrCallback): RemovalTarget => {
-    if (typeof elementOrCallback === "function") {
-        return elementOrCallback();
-    }
-    return elementOrCallback;
-};
+const getTarget = (elementOrCallback: ElementOrCallback): RemovalTarget =>
+    typeof elementOrCallback === "function" ? elementOrCallback() : elementOrCallback;
 
 const isWidgetRemoved = (widget: Gtk.Widget | null): boolean => {
-    if (widget === null) return true;
+    if (widget === null) {
+        return true;
+    }
 
     try {
         return widget.getRoot() === null;
@@ -78,13 +114,12 @@ const isWidgetRemoved = (widget: Gtk.Widget | null): boolean => {
 
 const isTargetRemoved = (target: RemovalTarget): boolean => {
     if (Array.isArray(target)) {
-        return target.length === 0 || target.every(isWidgetRemoved);
+        return target.every((widget) => isWidgetRemoved(widget));
     }
+
     return isWidgetRemoved(target);
 };
 
-const ELEMENT_NOT_REMOVED = new Error("Element not yet removed");
-
 /**
  * Waits until the given widget or widgets are detached from the tree. Rejects
  * immediately if the target is already absent when called.
@@ -93,11 +128,12 @@ const ELEMENT_NOT_REMOVED = new Error("Element not yet removed");
  * returning them to observe for removal.
  * @param options Optional timeout and interval settings.
  */
-export const waitForElementToBeRemoved = (
+const waitForElementToBeRemoved = (
     elementOrCallback: ElementOrCallback,
     options?: WaitForOptions,
 ): Promise<void> => {
     const stackTraceError = new Error("STACK_TRACE_MESSAGE");
+
     if (isTargetRemoved(getTarget(elementOrCallback))) {
         return Promise.reject(
             new Error(
@@ -105,10 +141,15 @@ export const waitForElementToBeRemoved = (
             ),
         );
     }
+
     return waitFor(
         () => {
-            if (!isTargetRemoved(getTarget(elementOrCallback))) throw ELEMENT_NOT_REMOVED;
+            if (!isTargetRemoved(getTarget(elementOrCallback))) {
+                throw ELEMENT_NOT_REMOVED;
+            }
         },
         { ...options, stackTraceError },
     );
 };
+
+export { waitFor, waitForElementToBeRemoved };