@gtkx/testing 0.20.0 → 1.0.0-rc.1

package/src/user-event/text.ts

@@ -0,0 +1,137 @@
+import * as Gdk from "@gtkx/gi/gdk";
+import * as GObject from "@gtkx/gi/gobject";
+import * as Gtk from "@gtkx/gi/gtk";
+import { EDITABLE_ROLES, type EditableTarget, getEditableDelegate, isEditable } from "../editable.js";
+import { formatRoleList } from "../role-helpers.js";
+import { wrapEvent } from "./event-wrapper.js";
+
+/** Options for {@link type}. */
+export 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. */
+    initialSelectionStart?: number | undefined;
+    /** End offset of the initial selection (defaults to the start offset). */
+    initialSelectionEnd?: number | undefined;
+};
+
+const EDITABLE_REQUIRED = `expected editable widget (${formatRoleList(EDITABLE_ROLES)})`;
+
+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;
+    }
+
+    const position = widget.getPosition();
+    const newPosition = widget.insertText(text, text.length, position);
+    widget.setPosition(newPosition);
+};
+
+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 applyInitialSelection = (widget: EditableTarget, options: TypeOptions): void => {
+    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);
+        return;
+    }
+    widget.selectRegion(start, end);
+    if (end !== start) widget.deleteSelection();
+    widget.setPosition(start);
+};
+
+const writeClipboardText = (widget: Gtk.Widget, text: string): void => {
+    const value = GObject.buildValue(GObject.TYPE_STRING, (v) => v.setString(text));
+    widget.getClipboard().set(value);
+};
+
+export const resetClipboard = (): void => {
+    Gdk.Display.getDefault()?.getClipboard().setContent(null);
+};
+
+export const type = (widget: Gtk.Widget, text: string, options?: TypeOptions): Promise<void> =>
+    wrapEvent(widget, () => {
+        if (!isEditable(widget)) {
+            throw new Error(`Cannot type into element: ${EDITABLE_REQUIRED}`);
+        }
+
+        if (!options?.skipClick) {
+            widget.grabFocus();
+        }
+
+        applyInitialSelection(widget, options ?? {});
+        insertEditableText(widget, text);
+    });
+
+export const clear = (widget: Gtk.Widget): Promise<void> =>
+    wrapEvent(widget, () => {
+        if (!isEditable(widget)) {
+            throw new Error(`Cannot clear element: ${EDITABLE_REQUIRED}`);
+        }
+
+        setEditableText(widget, "");
+    });
+
+export const copy = (widget: Gtk.Widget): Promise<void> =>
+    wrapEvent(widget, () => {
+        if (!isEditable(widget)) {
+            throw new Error(`Cannot copy: ${EDITABLE_REQUIRED}`);
+        }
+
+        writeClipboardText(widget, readSelection(widget));
+    });
+
+export const cut = (widget: Gtk.Widget): Promise<void> =>
+    wrapEvent(widget, () => {
+        if (!isEditable(widget)) {
+            throw new Error(`Cannot cut: ${EDITABLE_REQUIRED}`);
+        }
+
+        writeClipboardText(widget, readSelection(widget));
+        deleteSelection(widget);
+    });
+
+export 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);
+    });
+};

package/src/wait-for.ts

@@ -1,115 +1,114 @@
-import type * as Gtk from "@gtkx/ffi/gtk";
+import type * as Gtk from "@gtkx/gi/gtk";
+import { runWithActEnvironment } from "./act.js";
 import { getConfig } from "./config.js";
-import { buildTimeoutError } from "./error-builder.js";
+import { timeoutError } from "./errors.js";
 import type { WaitForOptions } from "./types.js";
 
 const DEFAULT_INTERVAL = 50;
 
+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);
+    }
+};
+
 /**
- * Waits for a callback to succeed.
- *
- * Repeatedly calls the callback until it returns without throwing,
- * or until the timeout is reached.
- *
- * @param callback - Function to execute repeatedly
- * @param options - Timeout and interval configuration
- * @returns Promise resolving to the callback's return value
- *
- * @example
- * ```tsx
- * import { waitFor } from "@gtkx/testing";
+ * Repeatedly invokes a callback until it succeeds without throwing or the
+ * timeout elapses, retrying on each rejection at a fixed interval.
  *
- * await waitFor(() => {
- *   expect(counter.value).toBe(5);
- * }, { timeout: 2000 });
- * ```
+ * @param callback The assertion or query to retry; its resolved value is returned.
+ * @param options Optional timeout, interval, and timeout error customization.
+ * @returns The callback's result once it succeeds.
  */
-export const waitFor = async <T>(callback: () => T | Promise<T>, options?: WaitForOptions): Promise<T> => {
-    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 {
-            return await callback();
-        } catch (error) {
-            lastError = error as Error;
-            await new Promise((resolve) => setTimeout(resolve, interval));
-        }
+export 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");
     }
 
-    const timeoutError = buildTimeoutError(timeout, lastError);
-    if (onTimeout) {
-        throw onTimeout(timeoutError);
-    }
-    throw timeoutError;
+    const stackTraceError = options?.stackTraceError ?? new Error("STACK_TRACE_MESSAGE");
+
+    return Promise.resolve(
+        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 error = timeoutError(timeout, lastError);
+            const finalError = onTimeout ? onTimeout(error) : error;
+            copyStackTrace(finalError, stackTraceError);
+            throw finalError;
+        }),
+    );
 };
 
-type ElementOrCallback = Gtk.Widget | (() => Gtk.Widget | null);
+type RemovalTarget = Gtk.Widget | Gtk.Widget[] | null;
+
+type ElementOrCallback = Gtk.Widget | Gtk.Widget[] | (() => RemovalTarget);
 
-const getElement = (elementOrCallback: ElementOrCallback): Gtk.Widget | null => {
+const getTarget = (elementOrCallback: ElementOrCallback): RemovalTarget => {
     if (typeof elementOrCallback === "function") {
         return elementOrCallback();
     }
     return elementOrCallback;
 };
 
-const isElementRemoved = (element: Gtk.Widget | null): boolean => {
-    if (element === null) return true;
+const isWidgetRemoved = (widget: Gtk.Widget | null): boolean => {
+    if (widget === null) return true;
 
     try {
-        const parent = element.getParent();
-        return parent === null;
+        return widget.getRoot() === null;
     } catch {
         return true;
     }
 };
 
+const isTargetRemoved = (target: RemovalTarget): boolean => {
+    if (Array.isArray(target)) {
+        return target.length === 0 || target.every(isWidgetRemoved);
+    }
+    return isWidgetRemoved(target);
+};
+
+const ELEMENT_NOT_REMOVED = new Error("Element not yet removed");
+
 /**
- * Waits for an element to be removed from the widget tree.
- *
- * Polls until the element no longer has a parent or no longer exists.
- *
- * @param elementOrCallback - Element or function returning element to watch
- * @param options - Timeout and interval configuration
- *
- * @example
- * ```tsx
- * import { waitForElementToBeRemoved } from "@gtkx/testing";
+ * Waits until the given widget or widgets are detached from the tree. Rejects
+ * immediately if the target is already absent when called.
  *
- * const loader = await screen.findByRole(Gtk.AccessibleRole.PROGRESS_BAR);
- * await waitForElementToBeRemoved(loader);
- * // Loader is now gone
- * ```
+ * @param elementOrCallback The widget, array of widgets, or a function
+ * returning them to observe for removal.
+ * @param options Optional timeout and interval settings.
  */
-export const waitForElementToBeRemoved = async (
+export const waitForElementToBeRemoved = (
     elementOrCallback: ElementOrCallback,
     options?: WaitForOptions,
 ): Promise<void> => {
-    const config = getConfig();
-    const { timeout = config.asyncUtilTimeout, interval = DEFAULT_INTERVAL, onTimeout } = options ?? {};
-
-    const initialElement = getElement(elementOrCallback);
-    if (initialElement === null || isElementRemoved(initialElement)) {
-        throw new Error(
-            "Element already removed: waitForElementToBeRemoved requires the element to be present initially",
+    const stackTraceError = new Error("STACK_TRACE_MESSAGE");
+    if (isTargetRemoved(getTarget(elementOrCallback))) {
+        return Promise.reject(
+            new Error(
+                "Element already removed: waitForElementToBeRemoved requires the element to be present initially",
+            ),
         );
     }
-
-    const startTime = Date.now();
-
-    while (Date.now() - startTime < timeout) {
-        const element = getElement(elementOrCallback);
-        if (isElementRemoved(element)) {
-            return;
-        }
-        await new Promise((resolve) => setTimeout(resolve, interval));
-    }
-
-    const timeoutError = new Error(`Timed out after ${timeout}ms waiting for element to be removed.`);
-    if (onTimeout) {
-        throw onTimeout(timeoutError);
-    }
-    throw timeoutError;
+    return waitFor(
+        () => {
+            if (!isTargetRemoved(getTarget(elementOrCallback))) throw ELEMENT_NOT_REMOVED;
+        },
+        { ...options, stackTraceError },
+    );
 };

package/src/widget-accessible-properties.ts

@@ -0,0 +1,244 @@
+import * as Gtk from "@gtkx/gi/gtk";
+import { getAccessibleMetadata } from "@gtkx/react/internal";
+import { EDITABLE_ROLES, isEditable, readEditableText } from "./editable.js";
+import { descendants } from "./traversal.js";
+
+const callStringGetter = (widget: Gtk.Widget, method: string): string | null => {
+    const fn: unknown = Reflect.get(widget, method);
+    if (typeof fn !== "function") return null;
+    const value = (fn as () => string | null).call(widget);
+    return value ?? null;
+};
+
+const readAccessibleString = (widget: Gtk.Widget, key: string): string | null => {
+    const value = getAccessibleMetadata<string>(widget, key);
+    return typeof value === "string" ? value : null;
+};
+
+const readAccessibleNumber = (widget: Gtk.Widget, key: string): number | null => {
+    const value = getAccessibleMetadata<number>(widget, key);
+    return typeof value === "number" ? value : null;
+};
+
+const readAccessibleBoolean = (widget: Gtk.Widget, key: string): boolean | null => {
+    const value = getAccessibleMetadata<boolean>(widget, key);
+    return typeof value === "boolean" ? value : null;
+};
+
+const getLabelText = (widget: Gtk.Widget): string | null => {
+    if (widget instanceof Gtk.Label) return widget.getLabel();
+    if (widget instanceof Gtk.Inscription) return widget.getText() ?? null;
+    return null;
+};
+
+const DEFAULT_TEXT_GETTERS = ["getLabel", "getText", "getTitle"] as const;
+
+/**
+ * Returns a widget's own text by trying its label, text, and title getters in
+ * order, or null when none produce a value.
+ *
+ * @param widget The widget to read text from.
+ */
+export const getWidgetNodeText = (widget: Gtk.Widget): string | null => {
+    for (const getter of DEFAULT_TEXT_GETTERS) {
+        const value = callStringGetter(widget, getter);
+        if (value) return value;
+    }
+    return null;
+};
+
+const stripMnemonic = (text: string): string => text.replace(/_(.)/g, "$1");
+
+const namingLabelText = (widget: Gtk.Widget): string | null => {
+    const text = getLabelText(widget);
+    if (text === null) return null;
+    return widget instanceof Gtk.Label && widget.getUseUnderline() ? stripMnemonic(text) : text;
+};
+
+const isNamingLabelRole = (role: Gtk.AccessibleRole, includePresentation: boolean): boolean =>
+    role === Gtk.AccessibleRole.LABEL || (includePresentation && role === Gtk.AccessibleRole.PRESENTATION);
+
+const collectLabels = (widget: Gtk.Widget): string[] => {
+    const includePresentation = widget.getAccessibleRole() === Gtk.AccessibleRole.MENU_ITEM;
+    const labels: string[] = [];
+    for (const descendant of descendants(widget)) {
+        if (!isNamingLabelRole(descendant.getAccessibleRole(), includePresentation)) continue;
+        const labelText = namingLabelText(descendant);
+        if (labelText) labels.push(labelText);
+    }
+    return labels;
+};
+
+export const getWidgetLabelText = (widget: Gtk.Widget): string | null => {
+    if (widget.getAccessibleRole() !== Gtk.AccessibleRole.LABEL) return null;
+    return getLabelText(widget);
+};
+
+export const getWidgetAccessibleName = (widget: Gtk.Widget): string | null => {
+    const role = widget.getAccessibleRole();
+
+    if (role === Gtk.AccessibleRole.TAB_PANEL) {
+        const parent = widget.getParent();
+        if (parent instanceof Gtk.Stack) {
+            const page = parent.getPage(widget);
+            return page.getTitle() ?? null;
+        }
+        return null;
+    }
+
+    const accessibleLabel = getAccessibleMetadata<string>(widget, "accessibleLabel");
+    if (accessibleLabel) return accessibleLabel;
+
+    const ownText = getWidgetNodeText(widget);
+    if (ownText) return ownText;
+
+    const childLabels = collectLabels(widget);
+    if (childLabels.length > 0) return childLabels.join(" ");
+
+    return callStringGetter(widget, "getTooltipText");
+};
+
+export const getWidgetName = (widget: Gtk.Widget): string | null => {
+    return widget.getName();
+};
+
+export const getWidgetPlaceholderText = (widget: Gtk.Widget): string | null => {
+    if (!EDITABLE_ROLES.has(widget.getAccessibleRole()) || !(widget instanceof Gtk.Editable)) {
+        return null;
+    }
+
+    return callStringGetter(widget, "getPlaceholderText");
+};
+
+export const getWidgetDisplayValue = (widget: Gtk.Widget): string | null => {
+    if (EDITABLE_ROLES.has(widget.getAccessibleRole()) && isEditable(widget)) {
+        return readEditableText(widget);
+    }
+
+    return null;
+};
+
+export const getWidgetCheckedState = (widget: Gtk.Widget): boolean | null => {
+    if (widget instanceof Gtk.CheckButton) return widget.getActive();
+    if (widget instanceof Gtk.Switch) return widget.getActive();
+    if (widget instanceof Gtk.ToggleButton && widget.getAccessibleRole() === Gtk.AccessibleRole.RADIO) {
+        return widget.getActive();
+    }
+    return null;
+};
+
+export const getWidgetPressedState = (widget: Gtk.Widget): boolean | null => {
+    if (widget instanceof Gtk.ToggleButton) return widget.getActive();
+    return null;
+};
+
+export const getWidgetExpandedState = (widget: Gtk.Widget): boolean | null => {
+    if (widget instanceof Gtk.Expander) {
+        return widget.getExpanded();
+    }
+
+    if (widget instanceof Gtk.TreeExpander) {
+        return widget.getListRow()?.getExpanded() ?? null;
+    }
+
+    return null;
+};
+
+export const getWidgetSelectedState = (widget: Gtk.Widget): boolean | null => {
+    if (widget instanceof Gtk.ListBoxRow) {
+        return widget.isSelected();
+    }
+
+    if (widget.getAccessibleRole() === Gtk.AccessibleRole.ROW) {
+        return (widget.getStateFlags() & Gtk.StateFlags.SELECTED) !== 0;
+    }
+
+    return null;
+};
+
+export const getWidgetLevel = (widget: Gtk.Widget): number | null => {
+    return readAccessibleNumber(widget, "accessibleLevel");
+};
+
+export const getWidgetInvalidState = (widget: Gtk.Widget): Gtk.AccessibleInvalidState | null => {
+    return getAccessibleMetadata<Gtk.AccessibleInvalidState>(widget, "accessibleInvalid");
+};
+
+export const getWidgetErrorMessage = (widget: Gtk.Widget): Gtk.Widget[] | null => {
+    const targets = getAccessibleMetadata<Gtk.Widget[]>(widget, "accessibleErrorMessage");
+    return Array.isArray(targets) && targets.length > 0 ? targets : null;
+};
+
+export const getWidgetBusyState = (widget: Gtk.Widget): boolean | null => {
+    return readAccessibleBoolean(widget, "accessibleBusy");
+};
+
+export const getWidgetDescription = (widget: Gtk.Widget): string | null => {
+    return readAccessibleString(widget, "accessibleDescription");
+};
+
+export type WidgetValue = {
+    now: number | null;
+    min: number | null;
+    max: number | null;
+    text: string | null;
+};
+
+type ValueTriplet = { now: number | null; min: number | null; max: number | null };
+
+const adjustmentValue = (adjustment: Gtk.Adjustment): ValueTriplet => ({
+    now: adjustment.getValue(),
+    min: adjustment.getLower(),
+    max: adjustment.getUpper(),
+});
+
+const getWidgetLiveValue = (widget: Gtk.Widget): ValueTriplet | null => {
+    if (widget instanceof Gtk.Range) return adjustmentValue(widget.getAdjustment());
+    if (widget instanceof Gtk.Scrollbar) return adjustmentValue(widget.getAdjustment());
+    if (widget instanceof Gtk.SpinButton) return adjustmentValue(widget.getAdjustment());
+    if (widget instanceof Gtk.ScaleButton) return adjustmentValue(widget.getAdjustment());
+    if (widget instanceof Gtk.LevelBar) {
+        return { now: widget.getValue(), min: widget.getMinValue(), max: widget.getMaxValue() };
+    }
+    if (widget instanceof Gtk.ProgressBar) return { now: widget.getFraction(), min: 0, max: 1 };
+    return null;
+};
+
+export const getWidgetValue = (widget: Gtk.Widget): WidgetValue => {
+    const text = readAccessibleString(widget, "accessibleValueText");
+    const live = getWidgetLiveValue(widget);
+    if (live) return { ...live, text };
+    return {
+        now: readAccessibleNumber(widget, "accessibleValueNow"),
+        min: readAccessibleNumber(widget, "accessibleValueMin"),
+        max: readAccessibleNumber(widget, "accessibleValueMax"),
+        text,
+    };
+};
+
+export const getWidgetOwnLabel = (widget: Gtk.Widget): string | null => {
+    return readAccessibleString(widget, "accessibleLabel");
+};
+
+export const getWidgetLabelledByText = (widget: Gtk.Widget): string | null => {
+    const targets = getAccessibleMetadata<Gtk.Widget[]>(widget, "accessibleLabelledBy");
+    if (!Array.isArray(targets) || targets.length === 0) return null;
+
+    const texts: string[] = [];
+    for (const target of targets) {
+        const text = getWidgetAccessibleName(target);
+        if (text !== null) texts.push(text);
+    }
+
+    return texts.length > 0 ? texts.join(" ") : null;
+};
+
+export const isInaccessible = (widget: Gtk.Widget): boolean => {
+    let current: Gtk.Widget | null = widget;
+    while (current) {
+        if (!current.getVisible()) return true;
+        if (readAccessibleBoolean(current, "accessibleHidden") === true) return true;
+        current = current.getParent();
+    }
+    return false;
+};

package/src/within.ts

@@ -1,31 +1,30 @@
-import type * as Gtk from "@gtkx/ffi/gtk";
-import { bindQueries } from "./bind-queries.js";
-import type { BoundQueries } from "./types.js";
+import type { BoundQueries } from "./bound-queries.js";
+import { builtinQueries } from "./queries.js";
+import type { Container } from "./traversal.js";
+import type { BoundCustomQueries, QueryMap } from "./types.js";
+
+const bindQuery =
+    <Args extends unknown[], Result>(query: (container: Container, ...args: Args) => Result, container: Container) =>
+    (...args: Args): Result =>
+        query(container, ...args);
+
+const bindCustomQueries = <Q extends QueryMap>(customQueries: Q, container: Container): BoundCustomQueries<Q> => {
+    const entries = Object.entries(customQueries).map(([key, query]) => [key, bindQuery(query, container)] as const);
+    return Object.fromEntries(entries) as BoundCustomQueries<Q>;
+};
 
 /**
- * Creates scoped query methods for a container widget.
- *
- * Use this to query within a specific section of your UI rather than
- * the entire application.
- *
- * @param container - The widget to scope queries to
- * @returns Object with query methods bound to the container
- *
- * @example
- * ```tsx
- * import { render, within } from "@gtkx/testing";
- *
- * test("scoped queries", async () => {
- *   await render(<MyPage />);
- *
- *   const sidebar = await screen.findByRole(Gtk.AccessibleRole.NAVIGATION);
- *   const sidebarQueries = within(sidebar);
- *
- *   // Only searches within the sidebar
- *   const navButton = await sidebarQueries.findByRole(Gtk.AccessibleRole.BUTTON);
- * });
- * ```
+ * Binds the built-in queries, and any custom queries, to a specific container
+ * so they search only within that scope.
  *
- * @see {@link screen} for global queries
+ * @param container The scope the returned queries operate on.
+ * @param queries Optional custom queries to bind alongside the built-in ones.
+ * @returns The queries bound to the container.
  */
-export const within = (container: Gtk.Widget): BoundQueries => bindQueries(container);
+export const within = <Q extends QueryMap = Record<never, never>>(
+    container: Container,
+    queries?: Q,
+): BoundQueries & BoundCustomQueries<Q> => ({
+    ...bindCustomQueries(builtinQueries, container),
+    ...(queries ? bindCustomQueries(queries, container) : ({} as BoundCustomQueries<Q>)),
+});

package/dist/bind-queries.d.ts

@@ -1,14 +0,0 @@
-import type { Container } from "./traversal.js";
-import type { BoundQueries } from "./types.js";
-type ContainerOrGetter = Container | (() => Container);
-/**
- * Binds all query functions to a container.
- *
- * @param containerOrGetter - The container to bind queries to, or a function that returns it
- * @returns Object with all query methods bound to the container
- *
- * @internal
- */
-export declare const bindQueries: (containerOrGetter: ContainerOrGetter) => BoundQueries;
-export {};
-//# sourceMappingURL=bind-queries.d.ts.map

package/dist/bind-queries.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bind-queries.d.ts","sourceRoot":"","sources":["../src/bind-queries.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAA8C,MAAM,YAAY,CAAC;AAE3F,KAAK,iBAAiB,GAAG,SAAS,GAAG,CAAC,MAAM,SAAS,CAAC,CAAC;AAKvD;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GAAI,mBAAmB,iBAAiB,KAAG,YAiCjE,CAAC"}

package/dist/bind-queries.js

@@ -1,29 +0,0 @@
-import * as queries from "./queries.js";
-const resolveContainer = (containerOrGetter) => typeof containerOrGetter === "function" ? containerOrGetter() : containerOrGetter;
-/**
- * Binds all query functions to a container.
- *
- * @param containerOrGetter - The container to bind queries to, or a function that returns it
- * @returns Object with all query methods bound to the container
- *
- * @internal
- */
-export const bindQueries = (containerOrGetter) => ({
-    queryByRole: (role, options) => queries.queryByRole(resolveContainer(containerOrGetter), role, options),
-    queryByLabelText: (text, options) => queries.queryByLabelText(resolveContainer(containerOrGetter), text, options),
-    queryByText: (text, options) => queries.queryByText(resolveContainer(containerOrGetter), text, options),
-    queryByTestId: (testId, options) => queries.queryByTestId(resolveContainer(containerOrGetter), testId, options),
-    queryAllByRole: (role, options) => queries.queryAllByRole(resolveContainer(containerOrGetter), role, options),
-    queryAllByLabelText: (text, options) => queries.queryAllByLabelText(resolveContainer(containerOrGetter), text, options),
-    queryAllByText: (text, options) => queries.queryAllByText(resolveContainer(containerOrGetter), text, options),
-    queryAllByTestId: (testId, options) => queries.queryAllByTestId(resolveContainer(containerOrGetter), testId, options),
-    findByRole: (role, options) => queries.findByRole(resolveContainer(containerOrGetter), role, options),
-    findByLabelText: (text, options) => queries.findByLabelText(resolveContainer(containerOrGetter), text, options),
-    findByText: (text, options) => queries.findByText(resolveContainer(containerOrGetter), text, options),
-    findByTestId: (testId, options) => queries.findByTestId(resolveContainer(containerOrGetter), testId, options),
-    findAllByRole: (role, options) => queries.findAllByRole(resolveContainer(containerOrGetter), role, options),
-    findAllByLabelText: (text, options) => queries.findAllByLabelText(resolveContainer(containerOrGetter), text, options),
-    findAllByText: (text, options) => queries.findAllByText(resolveContainer(containerOrGetter), text, options),
-    findAllByTestId: (testId, options) => queries.findAllByTestId(resolveContainer(containerOrGetter), testId, options),
-});
-//# sourceMappingURL=bind-queries.js.map