@ariakit/test 0.4.8 → 0.4.9

package/esm/__chunks/4VR4URFV.js

@@ -0,0 +1,119 @@
+"use client";
+import {
+  sleep
+} from "./DZ24E43J.js";
+import {
+  focus
+} from "./4SG6SLGL.js";
+import {
+  dispatch
+} from "./LK25WCYN.js";
+import {
+  wrapAsync
+} from "./HFG3HB6M.js";
+import {
+  __spreadValues
+} from "./SM5ASDQ3.js";
+
+// src/type.ts
+import { getActiveElement, isTextField } from "@ariakit/core/utils/dom";
+import { isFocusable } from "@ariakit/core/utils/focus";
+function getKeyFromChar(key) {
+  if (key === "\x7F") return "Delete";
+  if (key === "\b") return "Backspace";
+  if (key === "\n") return "Enter";
+  if (key === "	") return "Tab";
+  return key;
+}
+function workAroundEmailInput(element) {
+  const input = element;
+  if (input.tagName !== "INPUT" || input.type !== "email") return () => {
+  };
+  input.type = "text";
+  return () => {
+    input.type = "email";
+  };
+}
+function type(text, element, options = {}) {
+  return wrapAsync(async () => {
+    var _a, _b;
+    if (element == null) {
+      element = document.activeElement;
+    }
+    if (!element) return;
+    if (!isFocusable(element)) return;
+    await focus(element);
+    element.dirty = true;
+    const restoreEmailInput = workAroundEmailInput(element);
+    for (const char of text) {
+      const key = getKeyFromChar(char);
+      let value = "";
+      let inputType = options.isComposing ? "insertCompositionText" : "insertText";
+      let defaultAllowed = await dispatch.keyDown(element, __spreadValues({ key }, options));
+      element = getActiveElement(element) || element;
+      if (isTextField(element)) {
+        const input = element;
+        const [start, end] = [
+          (_a = input.selectionStart) != null ? _a : 0,
+          (_b = input.selectionEnd) != null ? _b : 0
+        ];
+        const collapsed = start === end;
+        let nextCaretPosition = start;
+        if (char === "\x7F") {
+          const firstPart = input.value.slice(0, start);
+          const secondPart = input.value.slice(collapsed ? end + 1 : end);
+          value = `${firstPart}${secondPart}`;
+          inputType = "deleteContentForward";
+        } else if (char === "\b") {
+          nextCaretPosition = collapsed ? Math.max(start - 1, 0) : start;
+          const firstPart = input.value.slice(0, nextCaretPosition);
+          const lastPart = input.value.slice(end, input.value.length);
+          value = `${firstPart}${lastPart}`;
+          inputType = "deleteContentBackward";
+        } else {
+          const firstPartEnd = options.isComposing ? start - 1 : start;
+          const firstPart = input.value.slice(0, firstPartEnd);
+          const lastPart = input.value.slice(end, input.value.length);
+          nextCaretPosition = start + 1;
+          value = `${firstPart}${char}${lastPart}`;
+        }
+        if (defaultAllowed && !input.readOnly) {
+          if (inputType === "insertText") {
+            defaultAllowed = await dispatch.keyPress(input, __spreadValues({
+              key,
+              charCode: key.charCodeAt(0)
+            }, options));
+          }
+          if (inputType === "insertCompositionText") {
+            defaultAllowed = await dispatch.compositionUpdate(input, __spreadValues({
+              data: char,
+              target: { value }
+            }, options));
+          }
+          if (defaultAllowed) {
+            await dispatch.input(input, __spreadValues({
+              data: char,
+              target: {
+                value,
+                selectionStart: nextCaretPosition,
+                selectionEnd: nextCaretPosition
+              },
+              inputType
+            }, options));
+            if (input.selectionStart !== nextCaretPosition) {
+              input.setSelectionRange(nextCaretPosition, nextCaretPosition);
+            }
+          }
+        }
+      }
+      await sleep();
+      await dispatch.keyUp(element, __spreadValues({ key }, options));
+      await sleep();
+    }
+    restoreEmailInput();
+  });
+}
+
+export {
+  type
+};

package/esm/__chunks/BG5U5JFH.js

@@ -0,0 +1,68 @@
+"use client";
+import {
+  sleep
+} from "./DZ24E43J.js";
+import {
+  dispatch
+} from "./LK25WCYN.js";
+import {
+  wrapAsync
+} from "./HFG3HB6M.js";
+import {
+  __spreadProps,
+  __spreadValues
+} from "./SM5ASDQ3.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/CSF4U66P.js

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

package/esm/__chunks/CWTUOQ5Z.js

@@ -0,0 +1,91 @@
+"use client";
+
+// src/__aria-role.ts
+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"
+];
+
+export {
+  roles
+};

package/esm/__chunks/DFUW3DFA.js

@@ -0,0 +1,134 @@
+"use client";
+import {
+  roles
+} from "./CWTUOQ5Z.js";
+import {
+  __spreadProps,
+  __spreadValues
+} from "./SM5ASDQ3.js";
+
+// src/query.ts
+import { invariant } from "@ariakit/core/utils/misc";
+import { queries as baseQueries } from "@testing-library/dom";
+function createQueries(container) {
+  return Object.entries(baseQueries).reduce((queries, [key, query2]) => {
+    queries[key] = (...args) => query2(container || document.body, ...args);
+    return queries;
+  }, {});
+}
+var documentQueries = createQueries();
+function matchName(name, accessibleName) {
+  if (accessibleName == null) return false;
+  if (typeof name === "string") {
+    return accessibleName === name;
+  }
+  return name.test(accessibleName);
+}
+function getNameOption(name, includesHidden) {
+  return (accessibleName, element) => {
+    if (!includesHidden && element.closest("[inert]")) return false;
+    if (!name) return true;
+    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, queries = documentQueries) {
+  const createQuery = (query3) => {
+    return (name, options) => {
+      return query3(role, __spreadValues({
+        name: getNameOption(name, options == null ? void 0 : options.hidden)
+      }, 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 createRoleQueries(queries = documentQueries) {
+  return roles.reduce((acc, role) => {
+    acc[role] = createRoleQuery(role, queries);
+    return acc;
+  }, {});
+}
+function createTextQuery(queries = documentQueries) {
+  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(queries = documentQueries) {
+  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 });
+}
+function createQueryObject(queries = documentQueries) {
+  return __spreadProps(__spreadValues({}, createRoleQueries(queries)), {
+    text: createTextQuery(queries),
+    labeled: createLabeledQuery(queries),
+    within: (element) => {
+      invariant(element, "Unable to create queries for null element");
+      return createQueryObject(createQueries(element));
+    }
+  });
+}
+var query = createQueryObject();
+var q = query;
+
+export {
+  query,
+  q
+};

package/esm/__chunks/DZ24E43J.js

@@ -0,0 +1,20 @@
+"use client";
+import {
+  isBrowser,
+  nextFrame,
+  wrapAsync
+} from "./HFG3HB6M.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/HFG3HB6M.js

@@ -0,0 +1,85 @@
+"use client";
+
+// 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 }];
+  };
+  if (!Element.prototype.scrollIntoView) {
+    Element.prototype.scrollIntoView = noop;
+  }
+  if (!Element.prototype.hasPointerCapture) {
+    Element.prototype.hasPointerCapture = noop;
+  }
+  if (!Element.prototype.setPointerCapture) {
+    Element.prototype.setPointerCapture = noop;
+  }
+  if (!Element.prototype.releasePointerCapture) {
+    Element.prototype.releasePointerCapture = noop;
+  }
+  if (typeof window.ClipboardEvent === "undefined") {
+    window.ClipboardEvent = class ClipboardEvent extends Event {
+    };
+  }
+  if (typeof window.PointerEvent === "undefined") {
+    window.PointerEvent = class PointerEvent extends MouseEvent {
+    };
+  }
+  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
+};