@ariakit/test 0.4.8 → 0.4.9

package/esm/__chunks/LK25WCYN.js

@@ -0,0 +1,202 @@
+"use client";
+import {
+  flushMicrotasks,
+  wrapAsync
+} from "./HFG3HB6M.js";
+
+// src/dispatch.ts
+import { getKeys, invariant } from "@ariakit/core/utils/misc";
+import { createEvent, fireEvent } from "@testing-library/dom";
+function assignProps(obj, props) {
+  for (const [key, value] of Object.entries(props)) {
+    Object.defineProperty(obj, key, { get: () => value != null ? value : null });
+  }
+}
+function sanitizeNumber(n) {
+  return Number(n != null ? n : 0);
+}
+function initClipboardEvent(event, { clipboardData }) {
+  assignProps(event, {
+    clipboardData
+  });
+}
+function initInputEvent(event, { data, inputType, isComposing }) {
+  assignProps(event, {
+    data,
+    isComposing: !!isComposing,
+    inputType: String(inputType)
+  });
+}
+function initUIEvent(event, { view, detail }) {
+  assignProps(event, {
+    view,
+    detail: sanitizeNumber(detail != null ? detail : 0)
+  });
+}
+function initUIEventModififiers(event, {
+  altKey,
+  ctrlKey,
+  metaKey,
+  shiftKey,
+  modifierAltGraph,
+  modifierCapsLock,
+  modifierFn,
+  modifierFnLock,
+  modifierNumLock,
+  modifierScrollLock,
+  modifierSymbol,
+  modifierSymbolLock
+}) {
+  assignProps(event, {
+    altKey: !!altKey,
+    ctrlKey: !!ctrlKey,
+    metaKey: !!metaKey,
+    shiftKey: !!shiftKey,
+    getModifierState(k) {
+      return Boolean(
+        {
+          Alt: altKey,
+          AltGraph: modifierAltGraph,
+          CapsLock: modifierCapsLock,
+          Control: ctrlKey,
+          Fn: modifierFn,
+          FnLock: modifierFnLock,
+          Meta: metaKey,
+          NumLock: modifierNumLock,
+          ScrollLock: modifierScrollLock,
+          Shift: shiftKey,
+          Symbol: modifierSymbol,
+          SymbolLock: modifierSymbolLock
+        }[k]
+      );
+    }
+  });
+}
+function initKeyboardEvent(event, { key, code, location, repeat, isComposing }) {
+  assignProps(event, {
+    key: String(key),
+    code: String(code),
+    location: sanitizeNumber(location),
+    repeat: !!repeat,
+    isComposing: !!isComposing
+  });
+}
+function initMouseEvent(event, {
+  x,
+  y,
+  screenX,
+  screenY,
+  clientX = x,
+  clientY = y,
+  button,
+  buttons,
+  relatedTarget
+}) {
+  assignProps(event, {
+    screenX: sanitizeNumber(screenX),
+    screenY: sanitizeNumber(screenY),
+    clientX: sanitizeNumber(clientX),
+    x: sanitizeNumber(clientX),
+    clientY: sanitizeNumber(clientY),
+    y: sanitizeNumber(clientY),
+    button: sanitizeNumber(button),
+    buttons: sanitizeNumber(buttons),
+    relatedTarget
+  });
+}
+function initPointerEvent(event, {
+  pointerId,
+  width,
+  height,
+  pressure,
+  tangentialPressure,
+  tiltX,
+  tiltY,
+  twist,
+  isPrimary,
+  pointerType = "mouse"
+}) {
+  assignProps(event, {
+    pointerId: sanitizeNumber(pointerId),
+    width: sanitizeNumber(width),
+    height: sanitizeNumber(height),
+    pressure: sanitizeNumber(pressure),
+    tangentialPressure: sanitizeNumber(tangentialPressure),
+    tiltX: sanitizeNumber(tiltX),
+    tiltY: sanitizeNumber(tiltY),
+    twist: sanitizeNumber(twist),
+    isPrimary: !!isPrimary,
+    pointerType: String(pointerType)
+  });
+}
+function initEvent(event, options = {}) {
+  if (event instanceof ClipboardEvent) {
+    initClipboardEvent(event, options);
+  }
+  if (event instanceof InputEvent) {
+    initInputEvent(event, options);
+  }
+  if (event instanceof UIEvent) {
+    initUIEvent(event, options);
+  }
+  if (event instanceof KeyboardEvent) {
+    initKeyboardEvent(event, options);
+    initUIEventModififiers(event, options);
+  }
+  if (event instanceof MouseEvent) {
+    initMouseEvent(event, options);
+    initUIEventModififiers(event, options);
+  }
+  if (event instanceof PointerEvent) {
+    initPointerEvent(event, options);
+  }
+}
+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);
+    initEvent(event, options);
+    return baseDispatch(element, event);
+  };
+  return events2;
+}, {});
+var dispatch = Object.assign(baseDispatch, events);
+
+export {
+  dispatch
+};

package/esm/__chunks/NR24PD4G.js

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

@@ -0,0 +1,236 @@
+"use client";
+import {
+  type
+} from "./4VR4URFV.js";
+import {
+  sleep
+} from "./DZ24E43J.js";
+import {
+  blur
+} from "./SOWA2DKF.js";
+import {
+  focus
+} from "./4SG6SLGL.js";
+import {
+  dispatch
+} from "./LK25WCYN.js";
+import {
+  wrapAsync
+} from "./HFG3HB6M.js";
+import {
+  __spreadValues
+} from "./SM5ASDQ3.js";
+
+// src/press.ts
+import { isTextField, setSelectionRange } from "@ariakit/core/utils/dom";
+import {
+  getNextTabbable,
+  getPreviousTabbable,
+  isFocusable
+} from "@ariakit/core/utils/focus";
+var clickableInputTypes = [
+  "button",
+  "color",
+  "file",
+  "image",
+  "reset",
+  "submit"
+];
+async 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) {
+    await dispatch.submit(form, options);
+  }
+}
+function isNumberInput(element) {
+  return element instanceof HTMLInputElement && element.type === "number";
+}
+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();
+  await dispatch.input(element);
+  await dispatch.change(element);
+}
+var keyDownMap = {
+  async Tab(_, { shiftKey }) {
+    const nextElement = shiftKey ? getPreviousTabbable() : getNextTabbable();
+    if (nextElement) {
+      await focus(nextElement);
+    }
+  },
+  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) {
+      await dispatch.click(element, options);
+    } else if (isSubmittable) {
+      await submitFormByPressingEnterOn(element, options);
+    }
+  },
+  async Home(element, { shiftKey }) {
+    if (isTextField(element)) {
+      const { value, selectionEnd } = element;
+      const end = Math.min(value.length, shiftKey ? selectionEnd != null ? selectionEnd : 0 : 0);
+      setSelectionRange(element, 0, end, "backward");
+    }
+  },
+  async End(element, { shiftKey }) {
+    if (isTextField(element)) {
+      const { value, selectionStart } = element;
+      const start = shiftKey ? selectionStart != null ? selectionStart : 0 : value.length;
+      setSelectionRange(element, start, value.length, "forward");
+    }
+  },
+  async ArrowLeft(element, { shiftKey }) {
+    if (isTextField(element)) {
+      const { value, selectionStart, selectionEnd, selectionDirection } = element;
+      const [start, end] = [selectionStart != null ? selectionStart : 0, selectionEnd != null ? 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);
+      setSelectionRange(
+        element,
+        nextStart,
+        nextEnd,
+        selectionDirection || "backward"
+      );
+    }
+  },
+  async ArrowRight(element, { shiftKey }) {
+    if (isTextField(element)) {
+      const { value, selectionStart, selectionEnd, selectionDirection } = element;
+      const [start, end] = [selectionStart != null ? selectionStart : 0, selectionEnd != null ? 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);
+      setSelectionRange(
+        element,
+        nextStart,
+        nextEnd,
+        selectionDirection || "forward"
+      );
+    }
+  },
+  async ArrowUp(element, { shiftKey }) {
+    if (isTextField(element)) {
+      if (!shiftKey) {
+        return setSelectionRange(element, 0, 0);
+      }
+      const { selectionStart, selectionEnd, selectionDirection } = element;
+      const [start, end] = [selectionStart != null ? selectionStart : 0, selectionEnd != null ? selectionEnd : 0];
+      if (selectionDirection === "forward") {
+        setSelectionRange(element, start, start);
+      } else {
+        setSelectionRange(element, 0, end, "backward");
+      }
+    } else if (isNumberInput(element)) {
+      await incrementNumberInput(element);
+    }
+  },
+  async ArrowDown(element, { shiftKey }) {
+    if (isTextField(element)) {
+      const length = element.value.length;
+      if (!shiftKey) {
+        setSelectionRange(element, length, length);
+      } else {
+        const { selectionStart, selectionEnd, selectionDirection } = element;
+        const [start, end] = [selectionStart != null ? selectionStart : 0, selectionEnd != null ? selectionEnd : 0];
+        if (selectionDirection === "backward") {
+          setSelectionRange(element, end, end);
+        } else {
+          setSelectionRange(element, start, length, "forward");
+        }
+      }
+    } else if (isNumberInput(element)) {
+      await incrementNumberInput(element, -1);
+    }
+  }
+};
+var keyUpMap = {
+  // Space
+  " ": async (element, options) => {
+    const spaceableTypes = [...clickableInputTypes, "checkbox", "radio"];
+    const isSpaceable = element.tagName === "BUTTON" || element instanceof HTMLInputElement && spaceableTypes.includes(element.type);
+    if (isSpaceable) {
+      await dispatch.click(element, options);
+    }
+  }
+};
+function press(key, element, options = {}) {
+  return wrapAsync(async () => {
+    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);
+      }
+    }
+    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));
+}
+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/RHBNMDK4.js

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

package/esm/__chunks/RTBDUQHD.js

@@ -0,0 +1,135 @@
+"use client";
+import {
+  hover
+} from "./BG5U5JFH.js";
+import {
+  sleep
+} from "./DZ24E43J.js";
+import {
+  mouseDown
+} from "./Z7WVAAXJ.js";
+import {
+  focus
+} from "./4SG6SLGL.js";
+import {
+  mouseUp
+} from "./NR24PD4G.js";
+import {
+  dispatch
+} from "./LK25WCYN.js";
+import {
+  wrapAsync
+} from "./HFG3HB6M.js";
+import {
+  __spreadValues
+} from "./SM5ASDQ3.js";
+
+// src/click.ts
+import { 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 element.closest("label");
+  }
+  return null;
+}
+function getInputFromLabel(element) {
+  var _a;
+  const input = element.htmlFor ? (_a = element.ownerDocument) == null ? void 0 : _a.getElementById(element.htmlFor) : element.querySelector("input,textarea,select");
+  return input;
+}
+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 = await dispatch.click(element, options);
+  if (input) {
+    input.disabled = isInputDisabled;
+    if (defaultAllowed && isFocusable(input)) {
+      await focus(input);
+      await dispatch.click(input);
+    }
+  }
+}
+function setSelected(element, selected) {
+  element.setAttribute("selected", selected ? "selected" : "");
+  element.selected = selected;
+}
+async function clickOption(element, eventOptions) {
+  const select = element.closest("select");
+  if (!select) {
+    await dispatch.click(element, eventOptions);
+    return;
+  }
+  if (select.multiple) {
+    const options = Array.from(select.options);
+    const resetOptions = () => {
+      for (const option of options) {
+        setSelected(option, false);
+      }
+    };
+    const selectRange = (a, b) => {
+      const from = Math.min(a, b);
+      const to = Math.max(a, b) + 1;
+      const selectedOptions = options.slice(from, to);
+      for (const option of selectedOptions) {
+        setSelected(option, true);
+      }
+    };
+    if (eventOptions == null ? void 0 : eventOptions.shiftKey) {
+      const elementIndex = options.indexOf(element);
+      const referenceOption = select.lastOptionSelectedNotByShiftKey;
+      const referenceOptionIndex = referenceOption ? options.indexOf(referenceOption) : -1;
+      resetOptions();
+      selectRange(elementIndex, referenceOptionIndex);
+      setSelected(element, true);
+    } else {
+      select.lastOptionSelectedNotByShiftKey = element;
+      if (eventOptions == null ? void 0 : eventOptions.ctrlKey) {
+        setSelected(element, !element.selected);
+      } else {
+        resetOptions();
+        setSelected(element, true);
+      }
+    }
+  } else {
+    setSelected(element, true);
+  }
+  await dispatch.input(select);
+  await dispatch.change(select);
+  await dispatch.click(element, eventOptions);
+}
+function click(element, options, tap = false) {
+  return wrapAsync(async () => {
+    invariant(element, "Unable to click on null element");
+    if (!isVisible(element)) return;
+    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();
+  });
+}
+
+export {
+  click
+};

package/esm/__chunks/SB7WYA2U.js

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

package/esm/__chunks/SM5ASDQ3.js

@@ -0,0 +1,25 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+export {
+  __spreadValues,
+  __spreadProps
+};

package/esm/__chunks/SOWA2DKF.js

@@ -0,0 +1,33 @@
+"use client";
+import {
+  dispatch
+} from "./LK25WCYN.js";
+import {
+  flushMicrotasks,
+  wrapAsync
+} from "./HFG3HB6M.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
+};