@ariakit/test 0.2.5 → 0.3.1

package/esm/__chunks/HUBUFZ3U.js

@@ -0,0 +1,205 @@
+"use client";
+import {
+  __spreadProps,
+  __spreadValues
+} from "./Q65FZOE2.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/HVRX3U4O.js

@@ -0,0 +1,126 @@
+"use client";
+import {
+  focus
+} from "./WAYMNUAF.js";
+import {
+  dispatch
+} from "./7JP5HWUW.js";
+import {
+  sleep
+} from "./YNAZUNNE.js";
+import {
+  wrapAsync
+} from "./LHKK7Y5F.js";
+import {
+  __spreadValues
+} from "./Q65FZOE2.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/LHKK7Y5F.js

@@ -0,0 +1,72 @@
+"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 }];
+  };
+  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/LSH2PT34.js

@@ -0,0 +1,30 @@
+"use client";
+import {
+  dispatch
+} from "./7JP5HWUW.js";
+import {
+  wrapAsync
+} from "./LHKK7Y5F.js";
+import {
+  __spreadValues
+} from "./Q65FZOE2.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/MKNCAN2F.js

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

package/esm/__chunks/{6XO5G2QR.js → Q65FZOE2.js}

@@ -1,3 +1,4 @@
+"use client";
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;

package/esm/__chunks/RG2JKALK.js

@@ -0,0 +1,58 @@
+"use client";
+import {
+  blur
+} from "./ZIWQZF7I.js";
+import {
+  focus
+} from "./WAYMNUAF.js";
+import {
+  dispatch
+} from "./7JP5HWUW.js";
+import {
+  wrapAsync
+} from "./LHKK7Y5F.js";
+import {
+  __spreadValues
+} from "./Q65FZOE2.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/RHBNMDK4.js

@@ -0,0 +1 @@
+"use client";