@gtkx/testing 1.0.0-rc.4 → 1.1.0

package/src/widget-getters.ts

@@ -0,0 +1,85 @@
+import type * as GObject from "@gtkx/gi/gobject";
+import type * as Gtk from "@gtkx/gi/gtk";
+import { getClassType, getInstanceType, TYPE_INVALID, typeName } from "@gtkx/runtime";
+import { resolveWrapperClass } from "@gtkx/runtime/internal";
+import { type AnyClass, walkClassChain } from "@gtkx/utils";
+
+const UNNAMED_TYPE_TAG = "Object";
+
+const getWidgetMethod = (widget: Gtk.Widget, name: string): unknown => Reflect.get(widget, name);
+const getWidgetTypeName = (widget: Gtk.Widget): string | null => typeName(getInstanceType(widget));
+const isClass = (value: unknown): value is AnyClass => typeof value === "function";
+
+const nonEmpty = (value: unknown): string | undefined =>
+    typeof value === "string" && value.length > 0 ? value : undefined;
+
+const getObjectClass = (object: GObject.Object): AnyClass | null => {
+    const cls: unknown = object.constructor;
+
+    return isClass(cls) ? cls : null;
+};
+
+const getNearestClassName = (object: GObject.Object): string | undefined =>
+    walkClassChain(getObjectClass(object), (ancestor) => nonEmpty(ancestor.name));
+
+const getUntypedClassName = (object: GObject.Object): string | undefined => {
+    const cls = getObjectClass(object);
+
+    return cls !== null && getClassType(cls) === TYPE_INVALID ? nonEmpty(cls.name) : undefined;
+};
+
+const getExactWrapperName = (type: bigint): string | undefined => {
+    const wrapper = resolveWrapperClass(type);
+
+    return wrapper !== null && getClassType(wrapper) === type ? nonEmpty(wrapper.name) : undefined;
+};
+
+const getTypeTag = (object: GObject.Object): string => {
+    const type = getInstanceType(object);
+
+    return (
+        getUntypedClassName(object) ??
+        getExactWrapperName(type) ??
+        nonEmpty(typeName(type)) ??
+        getNearestClassName(object) ??
+        UNNAMED_TYPE_TAG
+    );
+};
+
+const isDefaultWidgetName = (widget: Gtk.Widget, name: string): boolean =>
+    name.length === 0 || name === getWidgetTypeName(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,
+    getTypeTag,
+    getWidgetTypeName,
+    hasWidgetMethod,
+    isDefaultWidgetName,
+};

package/src/window-state.ts

@@ -0,0 +1,70 @@
+import * as Gtk from "@gtkx/gi/gtk";
+
+const WINDOW_NOT_ALLOCATED = "it was never allocated a size";
+const WINDOW_NOT_ACTIVATED = "it never became active";
+const NO_WINDOW_ACTIVATED = "no window of the application ever became active";
+
+const canDisplayDeliverActivation = (window: Gtk.Window): boolean => window.getDisplay().getDefaultSeat() !== null;
+const isWindow = (widget: Gtk.Widget): widget is Gtk.Window => widget instanceof Gtk.Window;
+
+const mappedToplevels = (): Gtk.Window[] =>
+    Gtk.Window.listToplevels().filter((widget) => isWindow(widget)).filter((window) => window.getMapped());
+
+const isWindowAllocated = (window: Gtk.Window): boolean => {
+    const [isComputed, allocation] = window.computeBounds(window);
+
+    return isComputed && allocation.getWidth() > 0;
+};
+
+const activeToplevel = (): Gtk.Window | null => mappedToplevels().find((toplevel) => toplevel.isActive()) ?? null;
+
+const isWindowActivated = (window: Gtk.Window): boolean =>
+    !canDisplayDeliverActivation(window) || window.isActive();
+
+const isApplicationActivated = (window: Gtk.Window): boolean =>
+    !canDisplayDeliverActivation(window) || activeToplevel() !== null;
+
+const isTransientDescendant = (window: Gtk.Window, ancestor: Gtk.Window): boolean => {
+    for (let parent = window.getTransientFor(); parent !== null; parent = parent.getTransientFor()) {
+        if (parent === ancestor) {
+            return true;
+        }
+    }
+
+    return false;
+};
+
+const isModalGrabHeldOver = (modal: Gtk.Window, window: Gtk.Window): boolean =>
+    modal.getModal() &&
+    modal !== window &&
+    modal.getGroup() === window.getGroup() &&
+    !isTransientDescendant(window, modal);
+
+const isWindowBlockedByModal = (window: Gtk.Window): boolean =>
+    mappedToplevels().some((toplevel) => isModalGrabHeldOver(toplevel, window));
+
+const findPresentedWindowFailure = (window: Gtk.Window): string | null => {
+    if (!isWindowAllocated(window)) {
+        return WINDOW_NOT_ALLOCATED;
+    }
+
+    return isWindowActivated(window) ? null : WINDOW_NOT_ACTIVATED;
+};
+
+const findRenderedWindowFailure = (window: Gtk.Window): string | null => {
+    if (!isWindowAllocated(window)) {
+        return WINDOW_NOT_ALLOCATED;
+    }
+
+    return isApplicationActivated(window) ? null : NO_WINDOW_ACTIVATED;
+};
+
+export {
+    activeToplevel,
+    findPresentedWindowFailure,
+    findRenderedWindowFailure,
+    isWindowActivated,
+    isWindowAllocated,
+    isWindowBlockedByModal,
+    mappedToplevels,
+};

package/src/within.ts

@@ -16,7 +16,8 @@ const bindCustomQueries = <Q extends QueryMap>(customQueries: Q, container: Cont
 
 /**
  * Binds the built-in queries, and any custom queries, to a specific container
- * so they search only within that scope.
+ * so they search only within that scope. Also exported as `getQueriesForElement`,
+ * which reads better in library code.
  *
  * @param container The scope the returned queries operate on.
  * @param queries Optional custom queries to bind alongside the built-in ones.
@@ -30,4 +31,4 @@ const within = <Q extends QueryMap = Record<never, never>>(
     ...(queries ? bindCustomQueries(queries, container) : ({} as BoundCustomQueries<Q>)),
 });
 
-export { within };
+export { within, within as getQueriesForElement };