@ariakit/test 0.2.5 → 0.3.0

package/esm/__chunks/BKSZ7WES.js

@@ -0,0 +1,204 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "./6XO5G2QR.js";
+
+// src/query.ts
+import { queries as baseQueries } from "@testing-library/dom";
+var roles = [
+  "alert",
+  "alertdialog",
+  "application",
+  "article",
+  "banner",
+  "blockquote",
+  "button",
+  "caption",
+  "cell",
+  "checkbox",
+  "code",
+  "columnheader",
+  "combobox",
+  "complementary",
+  "contentinfo",
+  "definition",
+  "deletion",
+  "dialog",
+  "directory",
+  "document",
+  "emphasis",
+  "feed",
+  "figure",
+  "form",
+  "generic",
+  "grid",
+  "gridcell",
+  "group",
+  "heading",
+  "img",
+  "insertion",
+  "link",
+  "list",
+  "listbox",
+  "listitem",
+  "log",
+  "main",
+  "marquee",
+  "math",
+  "menu",
+  "menubar",
+  "menuitem",
+  "menuitemcheckbox",
+  "menuitemradio",
+  "meter",
+  "navigation",
+  "none",
+  "note",
+  "option",
+  "paragraph",
+  "presentation",
+  "progressbar",
+  "radio",
+  "radiogroup",
+  "region",
+  "row",
+  "rowgroup",
+  "rowheader",
+  "scrollbar",
+  "search",
+  "searchbox",
+  "separator",
+  "slider",
+  "spinbutton",
+  "status",
+  "strong",
+  "subscript",
+  "superscript",
+  "switch",
+  "tab",
+  "table",
+  "tablist",
+  "tabpanel",
+  "term",
+  "textbox",
+  "time",
+  "timer",
+  "toolbar",
+  "tooltip",
+  "tree",
+  "treegrid",
+  "treeitem"
+];
+var queries = Object.entries(baseQueries).reduce((queries2, [key, query2]) => {
+  queries2[key] = (...args) => query2(document.body, ...args);
+  return queries2;
+}, {});
+function matchName(name, accessibleName) {
+  if (accessibleName == null)
+    return false;
+  if (typeof name === "string") {
+    return accessibleName === name;
+  }
+  return name.test(accessibleName);
+}
+function getNameOption(name) {
+  return (accessibleName, element) => {
+    if (matchName(name, accessibleName))
+      return true;
+    if (element.getAttribute("aria-label"))
+      return false;
+    const labeledBy = element.getAttribute("aria-labelledby");
+    if (!labeledBy) {
+      const content = "placeholder" in element && element.placeholder != null ? element.placeholder : element.textContent;
+      return matchName(name, content);
+    }
+    const label = document.getElementById(labeledBy);
+    if (!(label == null ? void 0 : label.textContent))
+      return false;
+    return matchName(name, label.textContent);
+  };
+}
+function createRoleQuery(role) {
+  const createQuery = (query3) => {
+    return (name, options) => {
+      if (!name) {
+        return query3(role, options);
+      }
+      return query3(role, __spreadValues({ name: getNameOption(name) }, options));
+    };
+  };
+  const createIncludesHidden = (query3) => (name, options) => query3(name, __spreadValues({ hidden: true }, options));
+  const query2 = createQuery(queries.queryByRole);
+  const allQuery = createQuery(queries.queryAllByRole);
+  const waitQuery = createQuery(queries.findByRole);
+  const waitAllQuery = createQuery(queries.findAllByRole);
+  const ensureQuery = createQuery(queries.getByRole);
+  const ensureAllQuery = createQuery(queries.getAllByRole);
+  const all = Object.assign(allQuery, {
+    includesHidden: createIncludesHidden(allQuery),
+    wait: Object.assign(waitAllQuery, {
+      includesHidden: createIncludesHidden(waitAllQuery)
+    }),
+    ensure: Object.assign(ensureAllQuery, {
+      includesHidden: createIncludesHidden(ensureAllQuery)
+    })
+  });
+  const wait = Object.assign(waitQuery, {
+    includesHidden: createIncludesHidden(waitQuery),
+    all: Object.assign(waitAllQuery, {
+      includesHidden: createIncludesHidden(waitAllQuery)
+    })
+  });
+  const ensure = Object.assign(ensureQuery, {
+    includesHidden: createIncludesHidden(ensureQuery),
+    all: Object.assign(ensureAllQuery, {
+      includesHidden: createIncludesHidden(ensureAllQuery)
+    })
+  });
+  return Object.assign(query2, {
+    includesHidden: createIncludesHidden(query2),
+    all,
+    wait,
+    ensure
+  });
+}
+function createTextQuery() {
+  const all = Object.assign(queries.queryAllByText, {
+    wait: queries.findAllByText,
+    ensure: queries.getAllByText
+  });
+  const wait = Object.assign(queries.findByText, {
+    all: queries.findAllByText
+  });
+  const ensure = Object.assign(queries.getByText, {
+    all: queries.getAllByText
+  });
+  return Object.assign(queries.queryByText, { all, wait, ensure });
+}
+function createLabeledQuery() {
+  const all = Object.assign(queries.queryAllByLabelText, {
+    wait: queries.findAllByLabelText,
+    ensure: queries.getAllByLabelText
+  });
+  const wait = Object.assign(queries.findByLabelText, {
+    all: queries.findAllByLabelText
+  });
+  const ensure = Object.assign(queries.getByLabelText, {
+    all: queries.getAllByLabelText
+  });
+  return Object.assign(queries.queryByLabelText, { all, wait, ensure });
+}
+var roleQueries = roles.reduce((acc, role) => {
+  acc[role] = createRoleQuery(role);
+  return acc;
+}, {});
+var query = __spreadProps(__spreadValues({}, roleQueries), {
+  text: createTextQuery(),
+  labeled: createLabeledQuery()
+});
+var q = query;
+
+export {
+  query,
+  q
+};

package/esm/__chunks/MOHPNQYM.js

@@ -0,0 +1,70 @@
+// src/__utils.ts
+import { isFocusable } from "@ariakit/core/utils/focus";
+import { noop } from "@ariakit/core/utils/misc";
+var isBrowser = typeof navigator !== "undefined" && !navigator.userAgent.includes("jsdom") && typeof window !== "undefined" && !("happyDOM" in window);
+async function flushMicrotasks() {
+  await Promise.resolve();
+  await Promise.resolve();
+  await Promise.resolve();
+}
+function nextFrame() {
+  return new Promise(requestAnimationFrame);
+}
+function setActEnvironment(value) {
+  const scope = globalThis;
+  const previousValue = scope.IS_REACT_ACT_ENVIRONMENT;
+  scope.IS_REACT_ACT_ENVIRONMENT = value;
+  const restoreActEnvironment = () => {
+    scope.IS_REACT_ACT_ENVIRONMENT = previousValue;
+  };
+  return restoreActEnvironment;
+}
+function applyBrowserPolyfills() {
+  if (isBrowser)
+    return noop;
+  const originalFocus = HTMLElement.prototype.focus;
+  HTMLElement.prototype.focus = function focus(options) {
+    if (!isFocusable(this))
+      return;
+    return originalFocus.call(this, options);
+  };
+  const originalGetClientRects = Element.prototype.getClientRects;
+  Element.prototype.getClientRects = function getClientRects() {
+    const isHidden = (element) => {
+      if (!element.isConnected)
+        return true;
+      if (element.parentElement && isHidden(element.parentElement))
+        return true;
+      if (!(element instanceof HTMLElement))
+        return false;
+      if (element.hidden)
+        return true;
+      const style = getComputedStyle(element);
+      return style.display === "none" || style.visibility === "hidden";
+    };
+    if (isHidden(this))
+      return [];
+    return [{ width: 1, height: 1 }];
+  };
+  return () => {
+    HTMLElement.prototype.focus = originalFocus;
+    Element.prototype.getClientRects = originalGetClientRects;
+  };
+}
+async function wrapAsync(fn) {
+  const restoreActEnvironment = setActEnvironment(false);
+  const removeBrowserPolyfills = applyBrowserPolyfills();
+  try {
+    return await fn();
+  } finally {
+    restoreActEnvironment();
+    removeBrowserPolyfills();
+  }
+}
+
+export {
+  isBrowser,
+  flushMicrotasks,
+  nextFrame,
+  wrapAsync
+};

package/esm/__chunks/PGGOW3IT.js

@@ -0,0 +1,57 @@
+import {
+  blur
+} from "./4NZZR22G.js";
+import {
+  focus
+} from "./Y4VDXWJ6.js";
+import {
+  dispatch
+} from "./ZU6UY6LZ.js";
+import {
+  wrapAsync
+} from "./MOHPNQYM.js";
+import {
+  __spreadValues
+} from "./6XO5G2QR.js";
+
+// src/mouse-down.ts
+import { getDocument, isVisible } from "@ariakit/core/utils/dom";
+import { getClosestFocusable, isFocusable } from "@ariakit/core/utils/focus";
+import { invariant } from "@ariakit/core/utils/misc";
+function mouseDown(element, options) {
+  return wrapAsync(async () => {
+    invariant(element, "Unable to mouseDown on null element");
+    if (!isVisible(element))
+      return;
+    const { disabled } = element;
+    let defaultAllowed = await dispatch.pointerDown(element, options);
+    if (!disabled) {
+      if (!await dispatch.mouseDown(element, __spreadValues({ detail: 1 }, options))) {
+        defaultAllowed = false;
+      }
+    }
+    if (defaultAllowed) {
+      const selection = getDocument(element).getSelection();
+      if (selection && selection.rangeCount) {
+        const range = selection.getRangeAt(0);
+        if (!range.collapsed) {
+          selection.removeAllRanges();
+        }
+      }
+      if (isFocusable(element) && getComputedStyle(element).pointerEvents !== "none") {
+        await focus(element);
+      } else if (element.parentElement) {
+        const closestFocusable = getClosestFocusable(element.parentElement);
+        if (closestFocusable) {
+          await focus(closestFocusable);
+        } else {
+          await blur();
+        }
+      }
+    }
+  });
+}
+
+export {
+  mouseDown
+};

package/esm/__chunks/SKXK6BOG.js

@@ -0,0 +1,29 @@
+import {
+  dispatch
+} from "./ZU6UY6LZ.js";
+import {
+  wrapAsync
+} from "./MOHPNQYM.js";
+import {
+  __spreadValues
+} from "./6XO5G2QR.js";
+
+// src/mouse-up.ts
+import { isVisible } from "@ariakit/core/utils/dom";
+import { invariant } from "@ariakit/core/utils/misc";
+function mouseUp(element, options) {
+  return wrapAsync(async () => {
+    invariant(element, "Unable to mouseUp on null element");
+    if (!isVisible(element))
+      return;
+    const { disabled } = element;
+    await dispatch.pointerUp(element, options);
+    if (disabled)
+      return;
+    await dispatch.mouseUp(element, __spreadValues({ detail: 1 }, options));
+  });
+}
+
+export {
+  mouseUp
+};

package/esm/__chunks/WWAF2MEB.js

@@ -0,0 +1,12 @@
+import {
+  click
+} from "./X5N4V7NJ.js";
+
+// src/tap.ts
+function tap(element, options) {
+  return click(element, options, true);
+}
+
+export {
+  tap
+};

package/esm/__chunks/{SWUQE4WB.js → X5N4V7NJ.js}

@@ -1,24 +1,24 @@
 import {
   mouseUp
-} from "./R7IYW63J.js";
+} from "./SKXK6BOG.js";
 import {
   mouseDown
-} from "./2OZA4WAZ.js";
+} from "./PGGOW3IT.js";
 import {
   hover
-} from "./EX5WPJOU.js";
+} from "./ZJJNX53K.js";
 import {
   focus
-} from "./OSCTTZUZ.js";
+} from "./Y4VDXWJ6.js";
 import {
-  fireEvent
-} from "./2RHTJFSK.js";
+  dispatch
+} from "./ZU6UY6LZ.js";
 import {
   sleep
-} from "./5PINJ4MD.js";
+} from "./YXZMMBB6.js";
 import {
-  queuedMicrotasks
-} from "./ZEO5Q6UD.js";
+  wrapAsync
+} from "./MOHPNQYM.js";
 import {
   __spreadValues
 } from "./6XO5G2QR.js";
@@ -26,6 +26,7 @@ import {
 // src/click.ts
 import { closest, isVisible } from "@ariakit/core/utils/dom";
 import { isFocusable } from "@ariakit/core/utils/focus";
+import { invariant } from "@ariakit/core/utils/misc";
 function getClosestLabel(element) {
   if (!isFocusable(element)) {
     return closest(element, "label");
@@ -37,18 +38,18 @@ function getInputFromLabel(element) {
   const input = element.htmlFor ? (_a = element.ownerDocument) == null ? void 0 : _a.getElementById(element.htmlFor) : element.querySelector("input,textarea,select");
   return input;
 }
-function clickLabel(element, options) {
+async function clickLabel(element, options) {
   const input = getInputFromLabel(element);
   const isInputDisabled = Boolean(input == null ? void 0 : input.disabled);
   if (input) {
     input.disabled = true;
   }
-  const defaultAllowed = fireEvent.click(element, options);
+  const defaultAllowed = await dispatch.click(element, options);
   if (input) {
     input.disabled = isInputDisabled;
     if (defaultAllowed && isFocusable(input)) {
-      focus(input);
-      fireEvent.click(input);
+      await focus(input);
+      await dispatch.click(input);
     }
   }
 }
@@ -56,10 +57,10 @@ function setSelected(element, selected) {
   element.setAttribute("selected", selected ? "selected" : "");
   element.selected = selected;
 }
-function clickOption(element, eventOptions) {
+async function clickOption(element, eventOptions) {
   const select = closest(element, "select");
   if (!select) {
-    fireEvent.click(element, eventOptions);
+    await dispatch.click(element, eventOptions);
     return;
   }
   if (select.multiple) {
@@ -94,37 +95,39 @@ function clickOption(element, eventOptions) {
   } else {
     setSelected(element, true);
   }
-  fireEvent.input(select);
-  fireEvent.change(select);
-  fireEvent.click(element, eventOptions);
+  await dispatch.input(select);
+  await dispatch.change(select);
+  await dispatch.click(element, eventOptions);
 }
-async function click(element, options, tap = false) {
-  if (!isVisible(element))
-    return;
-  await hover(element, options);
-  mouseDown(element, options);
-  await queuedMicrotasks();
-  while (!isVisible(element)) {
-    if (!element.parentElement)
+function click(element, options, tap = false) {
+  return wrapAsync(async () => {
+    invariant(element, "Unable to click on null element");
+    if (!isVisible(element))
       return;
-    element = element.parentElement;
-  }
-  if (!tap) {
+    await hover(element, options);
+    await mouseDown(element, options);
+    while (!isVisible(element)) {
+      if (!element.parentElement)
+        return;
+      element = element.parentElement;
+    }
+    if (!tap) {
+      await sleep();
+    }
+    await mouseUp(element, options);
+    const { disabled } = element;
+    if (disabled)
+      return;
+    const label = getClosestLabel(element);
+    if (label) {
+      await clickLabel(label, __spreadValues({ detail: 1 }, options));
+    } else if (element instanceof HTMLOptionElement) {
+      await clickOption(element, __spreadValues({ detail: 1 }, options));
+    } else {
+      await dispatch.click(element, __spreadValues({ detail: 1 }, options));
+    }
     await sleep();
-  }
-  mouseUp(element, options);
-  const { disabled } = element;
-  if (disabled)
-    return;
-  const label = getClosestLabel(element);
-  if (label) {
-    clickLabel(label, __spreadValues({ detail: 1 }, options));
-  } else if (element instanceof HTMLOptionElement) {
-    clickOption(element, __spreadValues({ detail: 1 }, options));
-  } else {
-    fireEvent.click(element, __spreadValues({ detail: 1 }, options));
-  }
-  await sleep();
+  });
 }
 
 export {

package/esm/__chunks/Y4VDXWJ6.js

@@ -0,0 +1,32 @@
+import {
+  dispatch
+} from "./ZU6UY6LZ.js";
+import {
+  flushMicrotasks,
+  wrapAsync
+} from "./MOHPNQYM.js";
+
+// src/focus.ts
+import { getActiveElement } from "@ariakit/core/utils/dom";
+import { isFocusable } from "@ariakit/core/utils/focus";
+import { invariant } from "@ariakit/core/utils/misc";
+function focus(element) {
+  return wrapAsync(async () => {
+    invariant(element, "Unable to focus on null element");
+    if (getActiveElement(element) === element)
+      return;
+    if (!isFocusable(element))
+      return;
+    const activeElement = getActiveElement(element);
+    if (activeElement == null ? void 0 : activeElement.dirty) {
+      await dispatch.change(activeElement);
+      activeElement.dirty = false;
+    }
+    element.focus();
+    await flushMicrotasks();
+  });
+}
+
+export {
+  focus
+};

package/esm/__chunks/YXZMMBB6.js

@@ -0,0 +1,19 @@
+import {
+  isBrowser,
+  nextFrame,
+  wrapAsync
+} from "./MOHPNQYM.js";
+
+// src/sleep.ts
+var defaultMs = isBrowser ? 150 : 10;
+function sleep(ms = defaultMs) {
+  return wrapAsync(async () => {
+    await nextFrame();
+    await new Promise((resolve) => setTimeout(resolve, ms));
+    await nextFrame();
+  });
+}
+
+export {
+  sleep
+};

package/esm/__chunks/ZJJNX53K.js

@@ -0,0 +1,68 @@
+import {
+  dispatch
+} from "./ZU6UY6LZ.js";
+import {
+  sleep
+} from "./YXZMMBB6.js";
+import {
+  wrapAsync
+} from "./MOHPNQYM.js";
+import {
+  __spreadProps,
+  __spreadValues
+} from "./6XO5G2QR.js";
+
+// src/hover.ts
+import { isVisible } from "@ariakit/core/utils/dom";
+import { invariant } from "@ariakit/core/utils/misc";
+function isPointerEventsEnabled(element) {
+  return getComputedStyle(element).pointerEvents !== "none";
+}
+function hover(element, options) {
+  return wrapAsync(async () => {
+    invariant(element, "Unable to hover on null element");
+    if (!isVisible(element))
+      return;
+    const document = element.ownerDocument;
+    const { lastHovered } = document;
+    const { disabled } = element;
+    const pointerEventsEnabled = isPointerEventsEnabled(element);
+    if (lastHovered && lastHovered !== element && isVisible(lastHovered)) {
+      await dispatch.pointerMove(lastHovered, options);
+      await dispatch.mouseMove(lastHovered, options);
+      if (isPointerEventsEnabled(lastHovered)) {
+        const isElementWithinLastHovered = lastHovered.contains(element);
+        const relatedTarget = pointerEventsEnabled ? element : null;
+        const leaveOptions = __spreadProps(__spreadValues({}, options), { relatedTarget });
+        await dispatch.pointerOut(lastHovered, leaveOptions);
+        if (!isElementWithinLastHovered) {
+          await dispatch.pointerLeave(lastHovered, leaveOptions);
+        }
+        await dispatch.mouseOut(lastHovered, leaveOptions);
+        if (!isElementWithinLastHovered) {
+          await dispatch.mouseLeave(lastHovered, leaveOptions);
+        }
+      }
+    }
+    await sleep();
+    if (pointerEventsEnabled) {
+      const enterOptions = lastHovered ? __spreadValues({ relatedTarget: lastHovered }, options) : options;
+      await dispatch.pointerOver(element, enterOptions);
+      await dispatch.pointerEnter(element, enterOptions);
+      if (!disabled) {
+        await dispatch.mouseOver(element, enterOptions);
+        await dispatch.mouseEnter(element, enterOptions);
+      }
+    }
+    await dispatch.pointerMove(element, options);
+    if (!disabled) {
+      await dispatch.mouseMove(element, options);
+    }
+    document.lastHovered = element;
+    await sleep();
+  });
+}
+
+export {
+  hover
+};

package/esm/__chunks/ZU6UY6LZ.js

@@ -0,0 +1,56 @@
+import {
+  flushMicrotasks,
+  wrapAsync
+} from "./MOHPNQYM.js";
+
+// src/dispatch.ts
+import { getKeys, invariant } from "@ariakit/core/utils/misc";
+import { createEvent, fireEvent } from "@testing-library/dom";
+var pointerEvents = [
+  "mousemove",
+  "mouseover",
+  "mouseenter",
+  "mouseout",
+  "mouseleave",
+  "mousedown",
+  "mouseup",
+  "pointermove",
+  "pointerover",
+  "pointerenter",
+  "pointerout",
+  "pointerleave",
+  "pointerdown",
+  "pointerup",
+  "click"
+];
+function baseDispatch(element, event) {
+  return wrapAsync(async () => {
+    invariant(element, `Unable to dispatch ${event.type} on null element`);
+    const eventName = event.type.toLowerCase();
+    if (pointerEvents.includes(eventName) && "classList" in element) {
+      const { pointerEvents: pointerEvents2 } = getComputedStyle(element);
+      if (pointerEvents2 === "none") {
+        if (element.parentElement) {
+          return baseDispatch(element.parentElement, event);
+        }
+        return true;
+      }
+    }
+    const defaultAllowed = fireEvent(element, event);
+    await flushMicrotasks();
+    return defaultAllowed;
+  });
+}
+var events = getKeys(fireEvent).reduce((events2, eventName) => {
+  events2[eventName] = (element, options) => {
+    invariant(element, `Unable to dispatch ${eventName} on null element`);
+    const event = createEvent[eventName](element, options);
+    return baseDispatch(element, event);
+  };
+  return events2;
+}, {});
+var dispatch = Object.assign(baseDispatch, events);
+
+export {
+  dispatch
+};