@ariakit/test 0.0.1 → 0.1.1

package/esm/__chunks/EFRHS5TP.js

@@ -0,0 +1,76 @@
+import {
+  mouseUp
+} from "./VZYZVUSK.js";
+import {
+  mouseDown
+} from "./XJFAU7OI.js";
+import {
+  hover
+} from "./RVXNT5Y5.js";
+import {
+  fireEvent
+} from "./B2UPDCBH.js";
+import {
+  sleep
+} from "./5PINJ4MD.js";
+
+// src/select.ts
+async function select(text, element = document.body, options) {
+  const document2 = element.ownerDocument;
+  await hover(element, options);
+  mouseDown(element, options);
+  element.dispatchEvent(
+    new Event("selectstart", {
+      bubbles: true,
+      cancelable: true,
+      composed: false
+    })
+  );
+  const startIndex = element.textContent?.indexOf(text) ?? -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?.removeAllRanges();
+    selection?.addRange(range);
+  }
+  await sleep();
+  mouseUp(element, options);
+  fireEvent.click(element, { detail: 1, ...options });
+  selection?.removeAllRanges();
+  selection?.addRange(range);
+  await sleep();
+}
+
+export {
+  select
+};

package/esm/__chunks/GW7B4E2U.js

@@ -0,0 +1,33 @@
+import {
+  fireEvent
+} from "./B2UPDCBH.js";
+import {
+  act
+} from "./ZEO5Q6UD.js";
+
+// src/blur.ts
+import { getActiveElement } from "@ariakit/core/utils/dom";
+function blur(element) {
+  if (element == null) {
+    element = document.activeElement;
+  }
+  if (!element)
+    return;
+  if (element.tagName === "BODY")
+    return;
+  if (getActiveElement(element) !== element)
+    return;
+  if (element.dirty) {
+    fireEvent.change(element);
+    element.dirty = false;
+  }
+  act(() => {
+    if (element instanceof HTMLElement || element instanceof SVGElement) {
+      element.blur();
+    }
+  });
+}
+
+export {
+  blur
+};

package/esm/__chunks/HCJFVOUB.js

@@ -0,0 +1,26 @@
+import {
+  isBrowser
+} from "./ZEO5Q6UD.js";
+
+// src/mock-get-client-rects.ts
+if (!isBrowser && typeof window !== "undefined") {
+  window.Element.prototype.getClientRects = function getClientRects() {
+    const isHidden = (element) => {
+      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 }];
+  };
+}

package/esm/__chunks/OHA2FPAE.js

@@ -0,0 +1,220 @@
+import {
+  type
+} from "./XKB6RJJC.js";
+import {
+  blur
+} from "./GW7B4E2U.js";
+import {
+  focus
+} from "./4RXBOOIA.js";
+import {
+  fireEvent
+} from "./B2UPDCBH.js";
+import {
+  sleep
+} from "./5PINJ4MD.js";
+import {
+  queuedMicrotasks
+} from "./ZEO5Q6UD.js";
+
+// src/press.ts
+import { isTextField } from "@ariakit/core/utils/dom";
+import {
+  getNextTabbable,
+  getPreviousTabbable,
+  isFocusable
+} from "@ariakit/core/utils/focus";
+var clickableInputTypes = [
+  "button",
+  "color",
+  "file",
+  "image",
+  "reset",
+  "submit"
+];
+function submitFormByPressingEnterOn(element, options) {
+  const { form } = element;
+  if (!form)
+    return;
+  const elements = Array.from(form.elements);
+  const validInputs = elements.filter(
+    (el) => el instanceof HTMLInputElement && isTextField(el)
+  );
+  const submitButton = elements.find(
+    (el) => (el instanceof HTMLInputElement || el instanceof HTMLButtonElement) && el.type === "submit"
+  );
+  if (validInputs.length === 1 || submitButton) {
+    fireEvent.submit(form, options);
+  }
+}
+function isNumberInput(element) {
+  return element instanceof HTMLInputElement && element.type === "number";
+}
+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);
+}
+var keyDownMap = {
+  Tab(_, { shiftKey }) {
+    const nextElement = shiftKey ? getPreviousTabbable() : getNextTabbable();
+    if (nextElement) {
+      focus(nextElement);
+    }
+  },
+  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);
+    } else if (isSubmittable) {
+      submitFormByPressingEnterOn(element, options);
+    }
+  },
+  ArrowLeft(element, { shiftKey }) {
+    if (isTextField(element)) {
+      const { value, selectionStart, selectionEnd, selectionDirection } = element;
+      const [start, end] = [selectionStart ?? 0, selectionEnd ?? 0];
+      const collapsing = !shiftKey && start !== end;
+      const nextStart = Math.max(0, collapsing ? start : start - 1);
+      const nextEnd = Math.min(value.length, shiftKey ? end : nextStart);
+      element.setSelectionRange(
+        nextStart,
+        nextEnd,
+        selectionDirection || "backward"
+      );
+    }
+  },
+  ArrowRight(element, { shiftKey }) {
+    if (isTextField(element)) {
+      const { value, selectionStart, selectionEnd, selectionDirection } = element;
+      const [start, end] = [selectionStart ?? 0, selectionEnd ?? 0];
+      const collapsing = !shiftKey && start !== end;
+      const nextEnd = Math.min(value.length, collapsing ? end : end + 1);
+      const nextStart = Math.max(0, shiftKey ? start : nextEnd);
+      element.setSelectionRange(
+        nextStart,
+        nextEnd,
+        selectionDirection || "forward"
+      );
+    }
+  },
+  ArrowUp(element, { shiftKey }) {
+    if (isTextField(element)) {
+      if (!shiftKey) {
+        return element.setSelectionRange(0, 0);
+      } else {
+        const { selectionStart, selectionEnd, selectionDirection } = element;
+        const [start, end] = [selectionStart ?? 0, selectionEnd ?? 0];
+        if (selectionDirection === "forward") {
+          element.setSelectionRange(start, start);
+        } else {
+          element.setSelectionRange(0, end, "backward");
+        }
+      }
+    } else if (isNumberInput(element)) {
+      incrementNumberInput(element);
+    }
+  },
+  ArrowDown(element, { shiftKey }) {
+    if (isTextField(element)) {
+      const length = element.value.length;
+      if (!shiftKey) {
+        element.setSelectionRange(length, length);
+      } else {
+        const { selectionStart, selectionEnd, selectionDirection } = element;
+        const [start, end] = [selectionStart ?? 0, selectionEnd ?? 0];
+        if (selectionDirection === "backward") {
+          element.setSelectionRange(end, end);
+        } else {
+          element.setSelectionRange(start, length, "forward");
+        }
+      }
+    } else if (isNumberInput(element)) {
+      incrementNumberInput(element, -1);
+    }
+  }
+};
+var keyUpMap = {
+  // Space
+  " ": (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);
+    }
+  }
+};
+async function press(key, element, options = {}) {
+  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);
+    }
+  }
+  if (element.ownerDocument?.activeElement !== element) {
+    if (element.tagName === "BODY") {
+      blur();
+    } else {
+      focus(element);
+    }
+  }
+  await sleep();
+  let defaultAllowed = fireEvent.keyDown(element, { key, ...options });
+  await queuedMicrotasks();
+  if (defaultAllowed && key in keyDownMap && !options.metaKey) {
+    keyDownMap[key]?.(element, options);
+  }
+  await sleep();
+  if (element.ownerDocument?.activeElement !== element) {
+    element = element.ownerDocument.activeElement;
+  }
+  if (!fireEvent.keyUp(element, { key, ...options })) {
+    defaultAllowed = false;
+  }
+  await queuedMicrotasks();
+  if (defaultAllowed && key in keyUpMap && !options.metaKey) {
+    keyUpMap[key]?.(element, options);
+  }
+  await sleep();
+}
+function createPress(key, defaultOptions = {}) {
+  return (element, options = {}) => press(key, element, { ...defaultOptions, ...options });
+}
+press.Escape = createPress("Escape");
+press.Backspace = createPress("Backspace");
+press.Delete = createPress("Delete");
+press.Tab = createPress("Tab");
+press.ShiftTab = createPress("Tab", { shiftKey: true });
+press.Enter = createPress("Enter");
+press.Space = createPress(" ");
+press.ArrowUp = createPress("ArrowUp");
+press.ArrowRight = createPress("ArrowRight");
+press.ArrowDown = createPress("ArrowDown");
+press.ArrowLeft = createPress("ArrowLeft");
+press.End = createPress("End");
+press.Home = createPress("Home");
+press.PageUp = createPress("PageUp");
+press.PageDown = createPress("PageDown");
+
+export {
+  press
+};

package/esm/__chunks/QA3ZS6S2.js

@@ -0,0 +1,6 @@
+// src/within.ts
+import { within } from "@testing-library/react";
+
+export {
+  within
+};

package/esm/__chunks/QZMWO6SS.js

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

package/esm/__chunks/RVXNT5Y5.js

@@ -0,0 +1,57 @@
+import {
+  fireEvent
+} from "./B2UPDCBH.js";
+import {
+  sleep
+} from "./5PINJ4MD.js";
+import {
+  queuedMicrotasks
+} from "./ZEO5Q6UD.js";
+
+// src/hover.ts
+function isPointerEventsEnabled(element) {
+  return getComputedStyle(element).pointerEvents !== "none";
+}
+async function hover(element, options) {
+  const document = element.ownerDocument;
+  const { lastHovered } = document;
+  const { disabled } = element;
+  const pointerEventsEnabled = isPointerEventsEnabled(element);
+  if (lastHovered && lastHovered !== element) {
+    fireEvent.pointerMove(lastHovered, options);
+    fireEvent.mouseMove(lastHovered, options);
+    if (isPointerEventsEnabled(lastHovered)) {
+      const isElementWithinLastHovered = lastHovered.contains(element);
+      const relatedTarget = pointerEventsEnabled ? element : null;
+      const leaveOptions = { ...options, relatedTarget };
+      fireEvent.pointerOut(lastHovered, leaveOptions);
+      if (!isElementWithinLastHovered) {
+        fireEvent.pointerLeave(lastHovered, leaveOptions);
+      }
+      fireEvent.mouseOut(lastHovered, leaveOptions);
+      if (!isElementWithinLastHovered) {
+        fireEvent.mouseLeave(lastHovered, leaveOptions);
+      }
+    }
+  }
+  await sleep();
+  if (pointerEventsEnabled) {
+    const enterOptions = lastHovered ? { relatedTarget: lastHovered, ...options } : options;
+    fireEvent.pointerOver(element, enterOptions);
+    fireEvent.pointerEnter(element, enterOptions);
+    if (!disabled) {
+      fireEvent.mouseOver(element, enterOptions);
+      fireEvent.mouseEnter(element, enterOptions);
+    }
+  }
+  fireEvent.pointerMove(element, options);
+  if (!disabled) {
+    fireEvent.mouseMove(element, options);
+  }
+  document.lastHovered = element;
+  await queuedMicrotasks();
+}
+
+export {
+  hover
+};

package/esm/__chunks/VZYZVUSK.js

@@ -0,0 +1,16 @@
+import {
+  fireEvent
+} from "./B2UPDCBH.js";
+
+// src/mouse-up.ts
+function mouseUp(element, options) {
+  const { disabled } = element;
+  fireEvent.pointerUp(element, options);
+  if (disabled)
+    return;
+  fireEvent.mouseUp(element, { detail: 1, ...options });
+}
+
+export {
+  mouseUp
+};

package/esm/__chunks/XJFAU7OI.js

@@ -0,0 +1,45 @@
+import {
+  blur
+} from "./GW7B4E2U.js";
+import {
+  focus
+} from "./4RXBOOIA.js";
+import {
+  fireEvent
+} from "./B2UPDCBH.js";
+
+// src/mouse-down.ts
+import { getDocument } from "@ariakit/core/utils/dom";
+import { getClosestFocusable, isFocusable } from "@ariakit/core/utils/focus";
+function mouseDown(element, options) {
+  const { disabled } = element;
+  let defaultAllowed = fireEvent.pointerDown(element, options);
+  if (!disabled) {
+    if (!fireEvent.mouseDown(element, { 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") {
+      focus(element);
+    } else if (element.parentElement) {
+      const closestFocusable = getClosestFocusable(element.parentElement);
+      if (closestFocusable) {
+        focus(closestFocusable);
+      } else {
+        blur();
+      }
+    }
+  }
+}
+
+export {
+  mouseDown
+};

package/esm/__chunks/XKB6RJJC.js

@@ -0,0 +1,110 @@
+import {
+  focus
+} from "./4RXBOOIA.js";
+import {
+  fireEvent
+} from "./B2UPDCBH.js";
+import {
+  sleep
+} from "./5PINJ4MD.js";
+import {
+  queuedMicrotasks
+} from "./ZEO5Q6UD.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";
+  };
+}
+async function type(text, element, options = {}) {
+  if (element == null) {
+    element = document.activeElement;
+  }
+  if (!element || !isFocusable(element))
+    return;
+  focus(element);
+  element.dirty = true;
+  const restoreEmailInput = workAroundEmailInput(element);
+  for (const char of text) {
+    const key = getKeyFromChar(char);
+    let value = "";
+    let inputType = "insertText";
+    let defaultAllowed = fireEvent.keyDown(element, { key, ...options });
+    await queuedMicrotasks();
+    element = getActiveElement(element) || element;
+    if (isTextField(element)) {
+      const input = element;
+      const [start, end] = [input.selectionStart ?? 0, input.selectionEnd ?? 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 firstPart = input.value.slice(0, start);
+        const lastPart = input.value.slice(end, input.value.length);
+        nextCaretPosition = start + 1;
+        value = `${firstPart}${char}${lastPart}`;
+      }
+      if (defaultAllowed && !input.readOnly) {
+        if (inputType === "insertText") {
+          defaultAllowed = fireEvent.keyPress(input, {
+            key,
+            charCode: key.charCodeAt(0),
+            ...options
+          });
+        }
+        if (defaultAllowed) {
+          fireEvent.input(input, {
+            data: char,
+            target: {
+              value,
+              selectionStart: nextCaretPosition,
+              selectionEnd: nextCaretPosition
+            },
+            inputType,
+            ...options
+          });
+          if (input.selectionStart !== nextCaretPosition) {
+            input.setSelectionRange(nextCaretPosition, nextCaretPosition);
+          }
+        }
+      }
+    }
+    await sleep();
+    fireEvent.keyUp(element, { key, ...options });
+    await sleep();
+  }
+  restoreEmailInput();
+}
+
+export {
+  type
+};

package/esm/__chunks/ZEO5Q6UD.js

@@ -0,0 +1,20 @@
+// src/__utils.ts
+import { act as reactAct } from "@testing-library/react";
+var isBrowser = typeof navigator !== "undefined" && !navigator.userAgent.includes("jsdom") && !("happyDOM" in window);
+var noopAct = (callback) => callback();
+var act = isBrowser ? noopAct : reactAct;
+function queuedMicrotasks() {
+  return act(() => Promise.resolve());
+}
+function nextFrame() {
+  return act(
+    () => new Promise((resolve) => requestAnimationFrame(() => resolve()))
+  );
+}
+
+export {
+  isBrowser,
+  act,
+  queuedMicrotasks,
+  nextFrame
+};

package/esm/__tests__/blur-test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/__tests__/use-all-events.d.ts

@@ -0,0 +1 @@
+export declare function useAllEvents(ref: React.RefObject<Element>, stack: string[]): void;

package/esm/__utils.d.ts

@@ -0,0 +1,8 @@
+export type DirtiableElement = Element & {
+    dirty?: boolean;
+};
+export type TextField = HTMLInputElement | HTMLTextAreaElement;
+export declare const isBrowser: boolean;
+export declare const act: typeof import("react-dom/test-utils").act;
+export declare function queuedMicrotasks(): Promise<void>;
+export declare function nextFrame(): Promise<void>;

package/esm/act.d.ts

@@ -0,0 +1 @@
+export { act } from "./__utils.js";

package/esm/act.js

@@ -0,0 +1,7 @@
+import "./__chunks/PNBZ5NXH.js";
+import {
+  act
+} from "./__chunks/ZEO5Q6UD.js";
+export {
+  act
+};

package/esm/blur.d.ts

@@ -0,0 +1,2 @@
+import type { DirtiableElement } from "./__utils.js";
+export declare function blur(element?: DirtiableElement | null): void;

package/esm/blur.js

@@ -0,0 +1,9 @@
+import {
+  blur
+} from "./__chunks/GW7B4E2U.js";
+import "./__chunks/B2UPDCBH.js";
+import "./__chunks/PNBZ5NXH.js";
+import "./__chunks/ZEO5Q6UD.js";
+export {
+  blur
+};

package/esm/click.d.ts

@@ -0,0 +1,2 @@
+import "./mock-get-client-rects.js";
+export declare function click(element: Element, options?: MouseEventInit, tap?: boolean): Promise<void>;