@ariakit/test 0.2.5 → 0.3.0

package/esm/__chunks/{6PY4HXVO.js → 2YBPSAHP.js}

@@ -1,21 +1,21 @@
 import {
   type
-} from "./4A3YKZRA.js";
+} from "./33MQDYWJ.js";
 import {
   blur
-} from "./AEOE57TZ.js";
+} from "./4NZZR22G.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";
@@ -35,7 +35,7 @@ var clickableInputTypes = [
   "reset",
   "submit"
 ];
-function submitFormByPressingEnterOn(element, options) {
+async function submitFormByPressingEnterOn(element, options) {
   const { form } = element;
   if (!form)
     return;
@@ -47,40 +47,40 @@ function submitFormByPressingEnterOn(element, options) {
     (el) => (el instanceof HTMLInputElement || el instanceof HTMLButtonElement) && el.type === "submit"
   );
   if (validInputs.length === 1 || submitButton) {
-    fireEvent.submit(form, options);
+    await dispatch.submit(form, options);
   }
 }
 function isNumberInput(element) {
   return element instanceof HTMLInputElement && element.type === "number";
 }
-function incrementNumberInput(element, by = 1) {
+async function incrementNumberInput(element, by = 1) {
   const value = +element.value + by;
   const max = element.max ? +element.max : Number.MAX_SAFE_INTEGER;
   const min = element.min ? +element.min : Number.MIN_SAFE_INTEGER;
   if (value > max || value < min)
     return;
   element.value = value.toString();
-  fireEvent.input(element);
-  fireEvent.change(element);
+  await dispatch.input(element);
+  await dispatch.change(element);
 }
 var keyDownMap = {
-  Tab(_, { shiftKey }) {
+  async Tab(_, { shiftKey }) {
     const nextElement = shiftKey ? getPreviousTabbable() : getNextTabbable();
     if (nextElement) {
-      focus(nextElement);
+      await focus(nextElement);
     }
   },
-  Enter(element, options) {
+  async Enter(element, options) {
     const nonSubmittableTypes = [...clickableInputTypes, "hidden"];
     const isClickable = element.tagName === "BUTTON" || element instanceof HTMLInputElement && clickableInputTypes.includes(element.type);
     const isSubmittable = element instanceof HTMLInputElement && !nonSubmittableTypes.includes(element.type);
     if (isClickable) {
-      fireEvent.click(element, options);
+      await dispatch.click(element, options);
     } else if (isSubmittable) {
-      submitFormByPressingEnterOn(element, options);
+      await submitFormByPressingEnterOn(element, options);
     }
   },
-  ArrowLeft(element, { shiftKey }) {
+  async ArrowLeft(element, { shiftKey }) {
     if (isTextField(element)) {
       const { value, selectionStart, selectionEnd, selectionDirection } = element;
       const [start, end] = [selectionStart != null ? selectionStart : 0, selectionEnd != null ? selectionEnd : 0];
@@ -94,7 +94,7 @@ var keyDownMap = {
       );
     }
   },
-  ArrowRight(element, { shiftKey }) {
+  async ArrowRight(element, { shiftKey }) {
     if (isTextField(element)) {
       const { value, selectionStart, selectionEnd, selectionDirection } = element;
       const [start, end] = [selectionStart != null ? selectionStart : 0, selectionEnd != null ? selectionEnd : 0];
@@ -108,7 +108,7 @@ var keyDownMap = {
       );
     }
   },
-  ArrowUp(element, { shiftKey }) {
+  async ArrowUp(element, { shiftKey }) {
     if (isTextField(element)) {
       if (!shiftKey) {
         return element.setSelectionRange(0, 0);
@@ -122,10 +122,10 @@ var keyDownMap = {
         }
       }
     } else if (isNumberInput(element)) {
-      incrementNumberInput(element);
+      await incrementNumberInput(element);
     }
   },
-  ArrowDown(element, { shiftKey }) {
+  async ArrowDown(element, { shiftKey }) {
     if (isTextField(element)) {
       const length = element.value.length;
       if (!shiftKey) {
@@ -140,65 +140,65 @@ var keyDownMap = {
         }
       }
     } else if (isNumberInput(element)) {
-      incrementNumberInput(element, -1);
+      await incrementNumberInput(element, -1);
     }
   }
 };
 var keyUpMap = {
   // Space
-  " ": (element, options) => {
+  " ": async (element, options) => {
     const spaceableTypes = [...clickableInputTypes, "checkbox", "radio"];
     const isSpaceable = element.tagName === "BUTTON" || element instanceof HTMLInputElement && spaceableTypes.includes(element.type);
     if (isSpaceable) {
-      fireEvent.click(element, options);
+      await dispatch.click(element, options);
     }
   }
 };
-async function press(key, element, options = {}) {
-  var _a, _b, _c, _d;
-  if (element == null) {
-    element = document.activeElement || document.body;
-  }
-  if (!element)
-    return;
-  if (!isFocusable(element) && element.tagName !== "BODY")
-    return;
-  if (isTextField(element)) {
-    if (key.length === 1) {
-      return type(key, element, options);
-    } else if (key === "Delete") {
-      return type("\x7F", element, options);
-    } else if (key === "Backspace") {
-      return type("\b", element, options);
-    } else if (key === "Enter" && element.tagName === "TEXTAREA") {
-      return type("\n", element, options);
+function press(key, element, options = {}) {
+  return wrapAsync(async () => {
+    var _a, _b, _c, _d;
+    if (element == null) {
+      element = document.activeElement || document.body;
     }
-  }
-  if (((_a = element.ownerDocument) == null ? void 0 : _a.activeElement) !== element) {
-    if (element.tagName === "BODY") {
-      blur();
-    } else {
-      focus(element);
+    if (!element)
+      return;
+    if (!isFocusable(element) && element.tagName !== "BODY")
+      return;
+    if (isTextField(element)) {
+      if (key.length === 1) {
+        return type(key, element, options);
+      } else if (key === "Delete") {
+        return type("\x7F", element, options);
+      } else if (key === "Backspace") {
+        return type("\b", element, options);
+      } else if (key === "Enter" && element.tagName === "TEXTAREA") {
+        return type("\n", element, options);
+      }
     }
-  }
-  await sleep();
-  let defaultAllowed = fireEvent.keyDown(element, __spreadValues({ key }, options));
-  await queuedMicrotasks();
-  if (defaultAllowed && key in keyDownMap && !options.metaKey) {
-    (_b = keyDownMap[key]) == null ? void 0 : _b.call(keyDownMap, element, options);
-  }
-  await sleep();
-  if (((_c = element.ownerDocument) == null ? void 0 : _c.activeElement) !== element) {
-    element = element.ownerDocument.activeElement;
-  }
-  if (!fireEvent.keyUp(element, __spreadValues({ key }, options))) {
-    defaultAllowed = false;
-  }
-  await queuedMicrotasks();
-  if (defaultAllowed && key in keyUpMap && !options.metaKey) {
-    (_d = keyUpMap[key]) == null ? void 0 : _d.call(keyUpMap, element, options);
-  }
-  await sleep();
+    if (((_a = element.ownerDocument) == null ? void 0 : _a.activeElement) !== element) {
+      if (element.tagName === "BODY") {
+        await blur();
+      } else {
+        await focus(element);
+      }
+    }
+    await sleep();
+    let defaultAllowed = await dispatch.keyDown(element, __spreadValues({ key }, options));
+    if (defaultAllowed && key in keyDownMap && !options.metaKey) {
+      await ((_b = keyDownMap[key]) == null ? void 0 : _b.call(keyDownMap, element, options));
+    }
+    await sleep();
+    if (((_c = element.ownerDocument) == null ? void 0 : _c.activeElement) !== element) {
+      element = element.ownerDocument.activeElement;
+    }
+    if (!await dispatch.keyUp(element, __spreadValues({ key }, options))) {
+      defaultAllowed = false;
+    }
+    if (defaultAllowed && key in keyUpMap && !options.metaKey) {
+      await ((_d = keyUpMap[key]) == null ? void 0 : _d.call(keyUpMap, element, options));
+    }
+    await sleep();
+  });
 }
 function createPress(key, defaultOptions = {}) {
   return (element, options = {}) => press(key, element, __spreadValues(__spreadValues({}, defaultOptions), options));

package/esm/__chunks/33MQDYWJ.js

@@ -0,0 +1,125 @@
+import {
+  focus
+} from "./Y4VDXWJ6.js";
+import {
+  dispatch
+} from "./ZU6UY6LZ.js";
+import {
+  sleep
+} from "./YXZMMBB6.js";
+import {
+  wrapAsync
+} from "./MOHPNQYM.js";
+import {
+  __spreadValues
+} from "./6XO5G2QR.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/45H4QFE4.js

@@ -0,0 +1,94 @@
+import {
+  mouseUp
+} from "./SKXK6BOG.js";
+import {
+  mouseDown
+} from "./PGGOW3IT.js";
+import {
+  hover
+} from "./ZJJNX53K.js";
+import {
+  dispatch
+} from "./ZU6UY6LZ.js";
+import {
+  sleep
+} from "./YXZMMBB6.js";
+import {
+  wrapAsync
+} from "./MOHPNQYM.js";
+import {
+  __spreadValues
+} from "./6XO5G2QR.js";
+
+// src/select.ts
+import { isVisible } from "@ariakit/core/utils/dom";
+import { invariant } from "@ariakit/core/utils/misc";
+function select(text, element = document.body, options) {
+  return wrapAsync(async () => {
+    var _a, _b;
+    invariant(element, "Unable to select text on null element");
+    if (!isVisible(element))
+      return;
+    const document2 = element.ownerDocument;
+    await hover(element, options);
+    await mouseDown(element, options);
+    await dispatch(
+      element,
+      new Event("selectstart", {
+        bubbles: true,
+        cancelable: true,
+        composed: false
+      })
+    );
+    const startIndex = (_b = (_a = element.textContent) == null ? void 0 : _a.indexOf(text)) != null ? _b : -1;
+    const selection = document2.getSelection();
+    const range = document2.createRange();
+    for (let i = 1; i <= text.length; i++) {
+      const iterator = document2.createNodeIterator(
+        element,
+        NodeFilter.SHOW_TEXT
+      );
+      const textSlice = text.slice(0, i);
+      const endIndex = startIndex + textSlice.length;
+      let index = startIndex;
+      let node = null;
+      let charCount = 0;
+      let startContainer = null;
+      let startOffset = -1;
+      let endContainer = null;
+      let endOffset = -1;
+      while (index >= 0 && index < endIndex && charCount < endIndex && (node = iterator.nextNode())) {
+        const textContent = node.textContent;
+        if (!textContent)
+          continue;
+        charCount += textContent.length;
+        if (index > charCount)
+          continue;
+        if (!startContainer) {
+          startContainer = node;
+          startOffset = index - charCount + textContent.length;
+        }
+        endContainer = node;
+        endOffset = endIndex - charCount + textContent.length;
+        index++;
+      }
+      if (!startContainer || !endContainer)
+        continue;
+      await hover(element, options);
+      range.setStart(startContainer, startOffset);
+      range.setEnd(endContainer, endOffset);
+      selection == null ? void 0 : selection.removeAllRanges();
+      selection == null ? void 0 : selection.addRange(range);
+    }
+    await sleep();
+    await mouseUp(element, options);
+    await dispatch.click(element, __spreadValues({ detail: 1 }, options));
+    selection == null ? void 0 : selection.removeAllRanges();
+    selection == null ? void 0 : selection.addRange(range);
+    await sleep();
+  });
+}
+
+export {
+  select
+};

package/esm/__chunks/4NZZR22G.js

@@ -0,0 +1,35 @@
+import {
+  dispatch
+} from "./ZU6UY6LZ.js";
+import {
+  flushMicrotasks,
+  wrapAsync
+} from "./MOHPNQYM.js";
+
+// src/blur.ts
+import { getActiveElement } from "@ariakit/core/utils/dom";
+function blur(element) {
+  return wrapAsync(async () => {
+    if (element == null) {
+      element = document.activeElement;
+    }
+    if (!element)
+      return;
+    if (element.tagName === "BODY")
+      return;
+    if (getActiveElement(element) !== element)
+      return;
+    if (element.dirty) {
+      await dispatch.change(element);
+      element.dirty = false;
+    }
+    if (element instanceof HTMLElement || element instanceof SVGElement) {
+      element.blur();
+      await flushMicrotasks();
+    }
+  });
+}
+
+export {
+  blur
+};

package/esm/__chunks/7I22ZP6R.js

@@ -0,0 +1,13 @@
+import {
+  wrapAsync
+} from "./MOHPNQYM.js";
+
+// src/wait-for.ts
+import * as DOMTestingLibrary from "@testing-library/dom";
+function waitFor2(callback, options) {
+  return wrapAsync(() => DOMTestingLibrary.waitFor(callback, options));
+}
+
+export {
+  waitFor2 as waitFor
+};