@ariakit/react 0.4.25 → 0.4.27

package/cjs/__chunks/LVHC4DSB.cjs

@@ -0,0 +1,117 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _NG34QRI6cjs = require('./NG34QRI6.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _QAUJZR6Ycjs = require('./QAUJZR6Y.cjs');
+
+// ../ariakit-react-components/dist/command/command.js
+var _react = require('react');
+var TagName = "button";
+function isNativeClick(event) {
+  if (!event.isTrusted) return false;
+  const element = event.currentTarget;
+  if (event.key === "Enter") return _QAUJZR6Ycjs.isButton.call(void 0, element) || element.tagName === "SUMMARY" || element.tagName === "A";
+  if (event.key === " ") return _QAUJZR6Ycjs.isButton.call(void 0, element) || element.tagName === "SUMMARY" || element.tagName === "INPUT" || element.tagName === "SELECT";
+  return false;
+}
+var symbol = /* @__PURE__ */ Symbol("command");
+var useCommand = _QAUJZR6Ycjs.createHook.call(void 0, function useCommand2({ clickOnEnter = true, clickOnSpace = true, ...props }) {
+  const ref = _react.useRef.call(void 0, null);
+  const [isNativeButton, setIsNativeButton] = _react.useState.call(void 0, false);
+  _react.useEffect.call(void 0, () => {
+    if (!ref.current) return;
+    setIsNativeButton(_QAUJZR6Ycjs.isButton.call(void 0, ref.current));
+  }, []);
+  const [active, setActive] = _react.useState.call(void 0, false);
+  const activeRef = _react.useRef.call(void 0, false);
+  const disabled = _QAUJZR6Ycjs.disabledFromProps.call(void 0, props);
+  const [isDuplicate, metadataProps] = _QAUJZR6Ycjs.useMetadataProps.call(void 0, props, symbol, true);
+  const onKeyDownProp = props.onKeyDown;
+  const onKeyDown = _QAUJZR6Ycjs.useEvent.call(void 0, (event) => {
+    onKeyDownProp == null ? void 0 : onKeyDownProp(event);
+    const element = event.currentTarget;
+    if (event.defaultPrevented) return;
+    if (isDuplicate) return;
+    if (disabled) return;
+    if (!_QAUJZR6Ycjs.isSelfTarget.call(void 0, event)) return;
+    if (_QAUJZR6Ycjs.isTextField.call(void 0, element)) return;
+    if (element.isContentEditable) return;
+    const isEnter = clickOnEnter && event.key === "Enter";
+    const isSpace = clickOnSpace && event.key === " ";
+    const shouldPreventEnter = event.key === "Enter" && !clickOnEnter;
+    const shouldPreventSpace = event.key === " " && !clickOnSpace;
+    if (shouldPreventEnter || shouldPreventSpace) {
+      event.preventDefault();
+      return;
+    }
+    if (isEnter || isSpace) {
+      const nativeClick = isNativeClick(event);
+      if (isEnter) {
+        if (!nativeClick) {
+          event.preventDefault();
+          const { view, ...eventInit } = event;
+          const click = () => _QAUJZR6Ycjs.fireClickEvent.call(void 0, element, eventInit);
+          if (_QAUJZR6Ycjs.isFirefox.call(void 0, )) _QAUJZR6Ycjs.queueBeforeEvent.call(void 0, element, "keyup", click);
+          else queueMicrotask(click);
+        }
+      } else if (isSpace) {
+        activeRef.current = true;
+        if (!nativeClick) {
+          event.preventDefault();
+          setActive(true);
+        }
+      }
+    }
+  });
+  const onKeyUpProp = props.onKeyUp;
+  const onKeyUp = _QAUJZR6Ycjs.useEvent.call(void 0, (event) => {
+    onKeyUpProp == null ? void 0 : onKeyUpProp(event);
+    if (event.defaultPrevented) return;
+    if (isDuplicate) return;
+    if (disabled) return;
+    if (event.metaKey) return;
+    const isSpace = clickOnSpace && event.key === " ";
+    if (activeRef.current && isSpace) {
+      activeRef.current = false;
+      if (!isNativeClick(event)) {
+        event.preventDefault();
+        setActive(false);
+        const element = event.currentTarget;
+        const { view, ...eventInit } = event;
+        queueMicrotask(() => _QAUJZR6Ycjs.fireClickEvent.call(void 0, element, eventInit));
+      }
+    }
+  });
+  props = {
+    "data-active": active || void 0,
+    type: isNativeButton ? "button" : void 0,
+    ...metadataProps,
+    ...props,
+    ref: _QAUJZR6Ycjs.useMergeRefs.call(void 0, ref, props.ref),
+    onKeyDown,
+    onKeyUp
+  };
+  props = _NG34QRI6cjs.useFocusable.call(void 0, props);
+  return props;
+});
+var Command = _QAUJZR6Ycjs.forwardRef.call(void 0, function Command2(props) {
+  return _QAUJZR6Ycjs.createElement.call(void 0, TagName, useCommand(props));
+});
+
+
+
+
+exports.useCommand = useCommand; exports.Command = Command;

package/cjs/__chunks/MN5TONXW.cjs

@@ -0,0 +1,123 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _L2IFVMDUcjs = require('./L2IFVMDU.cjs');
+
+
+
+var _SIF7IN4Lcjs = require('./SIF7IN4L.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _QAUJZR6Ycjs = require('./QAUJZR6Y.cjs');
+
+// ../ariakit-react-components/dist/composite/composite-group.js
+var TagName = "div";
+var useCompositeGroup = _QAUJZR6Ycjs.createHook.call(void 0, function useCompositeGroup2({ store, ...props }) {
+  props = _SIF7IN4Lcjs.useGroup.call(void 0, props);
+  return props;
+});
+var CompositeGroup = _QAUJZR6Ycjs.forwardRef.call(void 0, function CompositeGroup2(props) {
+  return _QAUJZR6Ycjs.createElement.call(void 0, TagName, useCompositeGroup(props));
+});
+
+// ../ariakit-react-components/dist/composite/composite-group-label.js
+var TagName2 = "div";
+var useCompositeGroupLabel = _QAUJZR6Ycjs.createHook.call(void 0, function useCompositeGroupLabel2({ store, ...props }) {
+  props = _SIF7IN4Lcjs.useGroupLabel.call(void 0, props);
+  return props;
+});
+var CompositeGroupLabel = _QAUJZR6Ycjs.forwardRef.call(void 0, function CompositeGroupLabel2(props) {
+  return _QAUJZR6Ycjs.createElement.call(void 0, TagName2, useCompositeGroupLabel(props));
+});
+
+// ../ariakit-react-components/dist/composite/composite-hover.js
+var _react = require('react');
+var TagName3 = "div";
+function getMouseDestination(event) {
+  const relatedTarget = event.relatedTarget;
+  if ((relatedTarget == null ? void 0 : relatedTarget.nodeType) === Node.ELEMENT_NODE) return relatedTarget;
+  return null;
+}
+function hoveringInside(event) {
+  const nextElement = getMouseDestination(event);
+  if (!nextElement) return false;
+  return _QAUJZR6Ycjs.contains.call(void 0, event.currentTarget, nextElement);
+}
+var symbol = /* @__PURE__ */ Symbol("composite-hover");
+function movingToAnotherItem(event) {
+  let dest = getMouseDestination(event);
+  if (!dest) return false;
+  do {
+    if (_QAUJZR6Ycjs.hasOwnProperty.call(void 0, dest, symbol) && dest[symbol]) return true;
+    dest = dest.parentElement;
+  } while (dest);
+  return false;
+}
+var useCompositeHover = _QAUJZR6Ycjs.createHook.call(void 0, function useCompositeHover2({ store, focusOnHover = true, blurOnHoverEnd = !!focusOnHover, ...props }) {
+  const context = _L2IFVMDUcjs.useCompositeContext.call(void 0, );
+  store = store || context;
+  _QAUJZR6Ycjs.invariant.call(void 0, store, "CompositeHover must be wrapped in a Composite component.");
+  const isMouseMoving = _QAUJZR6Ycjs.useIsMouseMoving.call(void 0, );
+  const onMouseMoveProp = props.onMouseMove;
+  const focusOnHoverProp = _QAUJZR6Ycjs.useBooleanEvent.call(void 0, focusOnHover);
+  const onMouseMove = _QAUJZR6Ycjs.useEvent.call(void 0, (event) => {
+    onMouseMoveProp == null ? void 0 : onMouseMoveProp(event);
+    if (event.defaultPrevented) return;
+    if (!isMouseMoving()) return;
+    if (!focusOnHoverProp(event)) return;
+    if (!_QAUJZR6Ycjs.hasFocusWithin.call(void 0, event.currentTarget)) {
+      const baseElement = store == null ? void 0 : store.getState().baseElement;
+      if (baseElement && !_QAUJZR6Ycjs.hasFocus.call(void 0, baseElement)) baseElement.focus();
+    }
+    store == null ? void 0 : store.setActiveId(event.currentTarget.id);
+  });
+  const onMouseLeaveProp = props.onMouseLeave;
+  const blurOnHoverEndProp = _QAUJZR6Ycjs.useBooleanEvent.call(void 0, blurOnHoverEnd);
+  const onMouseLeave = _QAUJZR6Ycjs.useEvent.call(void 0, (event) => {
+    var _a;
+    onMouseLeaveProp == null ? void 0 : onMouseLeaveProp(event);
+    if (event.defaultPrevented) return;
+    if (!isMouseMoving()) return;
+    if (hoveringInside(event)) return;
+    if (movingToAnotherItem(event)) return;
+    if (!focusOnHoverProp(event)) return;
+    if (!blurOnHoverEndProp(event)) return;
+    store == null ? void 0 : store.setActiveId(null);
+    (_a = store == null ? void 0 : store.getState().baseElement) == null ? void 0 : _a.focus();
+  });
+  const ref = _react.useCallback.call(void 0, (element) => {
+    if (!element) return;
+    element[symbol] = true;
+  }, []);
+  props = {
+    ...props,
+    ref: _QAUJZR6Ycjs.useMergeRefs.call(void 0, ref, props.ref),
+    onMouseMove,
+    onMouseLeave
+  };
+  return _QAUJZR6Ycjs.removeUndefinedValues.call(void 0, props);
+});
+var CompositeHover = _QAUJZR6Ycjs.memo.call(void 0, _QAUJZR6Ycjs.forwardRef.call(void 0, function CompositeHover2(props) {
+  return _QAUJZR6Ycjs.createElement.call(void 0, TagName3, useCompositeHover(props));
+}));
+
+
+
+
+
+
+
+
+exports.useCompositeGroup = useCompositeGroup; exports.CompositeGroup = CompositeGroup; exports.useCompositeGroupLabel = useCompositeGroupLabel; exports.CompositeGroupLabel = CompositeGroupLabel; exports.useCompositeHover = useCompositeHover; exports.CompositeHover = CompositeHover;

package/cjs/__chunks/N3DLR7OL.cjs

@@ -0,0 +1,34 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _RGH2H3WLcjs = require('./RGH2H3WL.cjs');
+
+
+
+
+var _QAUJZR6Ycjs = require('./QAUJZR6Y.cjs');
+
+// ../ariakit-react-components/dist/focus-trap/focus-trap.js
+var TagName = "span";
+var useFocusTrap = _QAUJZR6Ycjs.createHook.call(void 0, function useFocusTrap2(props) {
+  props = {
+    "data-focus-trap": "",
+    tabIndex: 0,
+    "aria-hidden": true,
+    ...props,
+    style: {
+      position: "fixed",
+      top: 0,
+      left: 0,
+      ...props.style
+    }
+  };
+  props = _RGH2H3WLcjs.useVisuallyHidden.call(void 0, props);
+  return props;
+});
+var FocusTrap = _QAUJZR6Ycjs.forwardRef.call(void 0, function FocusTrap2(props) {
+  return _QAUJZR6Ycjs.createElement.call(void 0, TagName, useFocusTrap(props));
+});
+
+
+
+exports.FocusTrap = FocusTrap;

package/cjs/__chunks/NFZWL7LE.cjs

@@ -0,0 +1,24 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+var _QAUJZR6Ycjs = require('./QAUJZR6Y.cjs');
+
+// ../ariakit-react-components/dist/separator/separator.js
+var TagName = "hr";
+var useSeparator = _QAUJZR6Ycjs.createHook.call(void 0, function useSeparator2({ orientation = "horizontal", ...props }) {
+  props = {
+    role: "separator",
+    "aria-orientation": orientation,
+    ...props
+  };
+  return props;
+});
+var Separator = _QAUJZR6Ycjs.forwardRef.call(void 0, function Separator2(props) {
+  return _QAUJZR6Ycjs.createElement.call(void 0, TagName, useSeparator(props));
+});
+
+
+
+
+exports.useSeparator = useSeparator; exports.Separator = Separator;

package/cjs/__chunks/NG34QRI6.cjs

@@ -0,0 +1,264 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _QAUJZR6Ycjs = require('./QAUJZR6Y.cjs');
+
+// ../ariakit-react-components/dist/focusable/focusable-context.js
+var _react = require('react');
+var FocusableContext = _react.createContext.call(void 0, true);
+
+// ../ariakit-react-components/dist/focusable/focusable.js
+
+var TagName = "div";
+var accessibleWhenDisabledSymbol = /* @__PURE__ */ Symbol("accessibleWhenDisabled");
+var isSafariBrowser = _QAUJZR6Ycjs.isSafari.call(void 0, );
+var alwaysFocusVisibleInputTypes = [
+  "text",
+  "search",
+  "url",
+  "tel",
+  "email",
+  "password",
+  "number",
+  "date",
+  "month",
+  "week",
+  "time",
+  "datetime",
+  "datetime-local"
+];
+function isAlwaysFocusVisible(element) {
+  const { tagName, readOnly, type } = element;
+  if (tagName === "TEXTAREA" && !readOnly) return true;
+  if (tagName === "SELECT" && !readOnly) return true;
+  if (tagName === "INPUT" && !readOnly) return alwaysFocusVisibleInputTypes.includes(type);
+  if (element.isContentEditable) return true;
+  if (element.getAttribute("role") === "combobox" && element.dataset.name) return true;
+  return false;
+}
+function isNativeTabbable(tagName) {
+  if (!tagName) return true;
+  return tagName === "button" || tagName === "summary" || tagName === "input" || tagName === "select" || tagName === "textarea" || tagName === "a";
+}
+function supportsDisabledAttribute(tagName) {
+  if (!tagName) return true;
+  return tagName === "button" || tagName === "input" || tagName === "select" || tagName === "textarea";
+}
+var buttonInputTypes = [
+  "button",
+  "color",
+  "file",
+  "image",
+  "reset",
+  "submit"
+];
+function needsSafariTabIndex(tagName, inputType) {
+  if (tagName === "button") return true;
+  if (tagName === "input" && inputType) {
+    if (inputType === "checkbox" || inputType === "radio") return true;
+    return buttonInputTypes.includes(inputType);
+  }
+  return false;
+}
+function getTabIndex({ focusable, trulyDisabled, nativeTabbable, supportsDisabled, safariTabIndex, tabIndexProp }) {
+  if (!focusable) return tabIndexProp;
+  if (trulyDisabled) {
+    if (nativeTabbable && !supportsDisabled) return -1;
+    return;
+  }
+  if (nativeTabbable) {
+    if (safariTabIndex && tabIndexProp == null) return 0;
+    return tabIndexProp;
+  }
+  return tabIndexProp != null ? tabIndexProp : 0;
+}
+function useDisableEvent(onEvent, disabled) {
+  return _QAUJZR6Ycjs.useEvent.call(void 0, (event) => {
+    onEvent == null ? void 0 : onEvent(event);
+    if (event.defaultPrevented) return;
+    if (disabled) {
+      event.stopPropagation();
+      event.preventDefault();
+    }
+  });
+}
+var hasInstalledGlobalEventListeners = false;
+var isKeyboardModality = true;
+function onGlobalMouseDown(event) {
+  const target = event.target;
+  if (target && "hasAttribute" in target) {
+    if (!target.hasAttribute("data-focus-visible")) isKeyboardModality = false;
+  }
+}
+function onGlobalKeyDown(event) {
+  if (event.metaKey) return;
+  if (event.ctrlKey) return;
+  if (event.altKey) return;
+  isKeyboardModality = true;
+}
+var useFocusable = _QAUJZR6Ycjs.createHook.call(void 0, function useFocusable2({ focusable = true, accessibleWhenDisabled, autoFocus, onFocusVisible, ...props }) {
+  const ref = _react.useRef.call(void 0, null);
+  const [parentAccessibleWhenDisabled, metadataProps] = _QAUJZR6Ycjs.useMetadataProps.call(void 0, props, accessibleWhenDisabledSymbol, accessibleWhenDisabled);
+  accessibleWhenDisabled != null ? accessibleWhenDisabled : accessibleWhenDisabled = parentAccessibleWhenDisabled;
+  _react.useEffect.call(void 0, () => {
+    if (!focusable) return;
+    if (hasInstalledGlobalEventListeners) return;
+    _QAUJZR6Ycjs.addGlobalEventListener.call(void 0, "mousedown", onGlobalMouseDown, true);
+    _QAUJZR6Ycjs.addGlobalEventListener.call(void 0, "keydown", onGlobalKeyDown, true);
+    hasInstalledGlobalEventListeners = true;
+  }, [focusable]);
+  const disabled = focusable && _QAUJZR6Ycjs.disabledFromProps.call(void 0, props);
+  const trulyDisabled = disabled && !accessibleWhenDisabled;
+  const [focusVisible, setFocusVisible] = _react.useState.call(void 0, false);
+  _react.useEffect.call(void 0, () => {
+    if (!focusable) return;
+    if (trulyDisabled && focusVisible) setFocusVisible(false);
+  }, [
+    focusable,
+    trulyDisabled,
+    focusVisible
+  ]);
+  _react.useEffect.call(void 0, () => {
+    if (!focusable) return;
+    if (!focusVisible) return;
+    const element = ref.current;
+    if (!element) return;
+    if (typeof IntersectionObserver === "undefined") return;
+    const observer = new IntersectionObserver(() => {
+      if (!_QAUJZR6Ycjs.isFocusable.call(void 0, element)) setFocusVisible(false);
+    });
+    observer.observe(element);
+    return () => observer.disconnect();
+  }, [focusable, focusVisible]);
+  const onKeyPressCapture = useDisableEvent(props.onKeyPressCapture, disabled);
+  const onMouseDownCapture = useDisableEvent(props.onMouseDownCapture, disabled);
+  const onClickCapture = useDisableEvent(props.onClickCapture, disabled);
+  const handleFocusVisible = (event, currentTarget) => {
+    if (currentTarget) event.currentTarget = currentTarget;
+    if (!focusable) return;
+    const element = event.currentTarget;
+    if (!element) return;
+    if (!_QAUJZR6Ycjs.hasFocus.call(void 0, element)) return;
+    onFocusVisible == null ? void 0 : onFocusVisible(event);
+    if (event.defaultPrevented) return;
+    element.dataset.focusVisible = "true";
+    setFocusVisible(true);
+  };
+  const onKeyDownCaptureProp = props.onKeyDownCapture;
+  const onKeyDownCapture = _QAUJZR6Ycjs.useEvent.call(void 0, (event) => {
+    onKeyDownCaptureProp == null ? void 0 : onKeyDownCaptureProp(event);
+    if (event.defaultPrevented) return;
+    if (!focusable) return;
+    if (focusVisible) return;
+    if (event.metaKey) return;
+    if (event.altKey) return;
+    if (event.ctrlKey) return;
+    if (!_QAUJZR6Ycjs.isSelfTarget.call(void 0, event)) return;
+    const element = event.currentTarget;
+    const applyFocusVisible = () => handleFocusVisible(event, element);
+    _QAUJZR6Ycjs.queueBeforeEvent.call(void 0, element, "focusout", applyFocusVisible);
+  });
+  const onFocusCaptureProp = props.onFocusCapture;
+  const onFocusCapture = _QAUJZR6Ycjs.useEvent.call(void 0, (event) => {
+    onFocusCaptureProp == null ? void 0 : onFocusCaptureProp(event);
+    if (event.defaultPrevented) return;
+    if (!focusable) return;
+    if (!_QAUJZR6Ycjs.isSelfTarget.call(void 0, event)) {
+      setFocusVisible(false);
+      return;
+    }
+    const element = event.currentTarget;
+    const applyFocusVisible = () => handleFocusVisible(event, element);
+    if (isKeyboardModality || isAlwaysFocusVisible(event.target)) _QAUJZR6Ycjs.queueBeforeEvent.call(void 0, event.target, "focusout", applyFocusVisible);
+    else setFocusVisible(false);
+  });
+  const onBlurProp = props.onBlur;
+  const onBlur = _QAUJZR6Ycjs.useEvent.call(void 0, (event) => {
+    onBlurProp == null ? void 0 : onBlurProp(event);
+    if (!focusable) return;
+    if (!_QAUJZR6Ycjs.isFocusEventOutside.call(void 0, event)) return;
+    event.currentTarget.removeAttribute("data-focus-visible");
+    setFocusVisible(false);
+  });
+  const autoFocusOnShow = _react.useContext.call(void 0, FocusableContext);
+  const autoFocusRef = _QAUJZR6Ycjs.useEvent.call(void 0, (element) => {
+    if (!focusable) return;
+    if (!autoFocus) return;
+    if (!element) return;
+    if (!autoFocusOnShow) return;
+    queueMicrotask(() => {
+      if (_QAUJZR6Ycjs.hasFocus.call(void 0, element)) return;
+      if (!_QAUJZR6Ycjs.isFocusable.call(void 0, element)) return;
+      element.focus();
+    });
+  });
+  const tagName = _QAUJZR6Ycjs.useTagName.call(void 0, ref);
+  const nativeTabbable = focusable && isNativeTabbable(tagName);
+  const supportsDisabled = focusable && supportsDisabledAttribute(tagName);
+  const [safariTabIndex, setSafariTabIndex] = _react.useState.call(void 0, false);
+  if (isSafariBrowser) _react.useEffect.call(void 0, () => {
+    if (!focusable) return;
+    const element = ref.current;
+    if (!element) return;
+    const tag = element.tagName.toLowerCase();
+    const type = element.type;
+    setSafariTabIndex(needsSafariTabIndex(tag, type));
+  }, [focusable]);
+  const styleProp = props.style;
+  const style = _react.useMemo.call(void 0, () => {
+    if (trulyDisabled) return {
+      pointerEvents: "none",
+      ...styleProp
+    };
+    return styleProp;
+  }, [trulyDisabled, styleProp]);
+  props = {
+    "data-focus-visible": focusable && focusVisible || void 0,
+    "data-autofocus": autoFocus || void 0,
+    "aria-disabled": disabled || void 0,
+    ...props,
+    ...metadataProps,
+    ref: _QAUJZR6Ycjs.useMergeRefs.call(void 0, ref, autoFocusRef, props.ref),
+    style,
+    tabIndex: getTabIndex({
+      focusable,
+      trulyDisabled,
+      nativeTabbable,
+      supportsDisabled,
+      safariTabIndex,
+      tabIndexProp: props.tabIndex
+    }),
+    disabled: supportsDisabled && trulyDisabled ? true : void 0,
+    contentEditable: disabled ? void 0 : props.contentEditable,
+    onKeyPressCapture,
+    onClickCapture,
+    onMouseDownCapture,
+    onKeyDownCapture,
+    onFocusCapture,
+    onBlur
+  };
+  return _QAUJZR6Ycjs.removeUndefinedValues.call(void 0, props);
+});
+var Focusable = _QAUJZR6Ycjs.forwardRef.call(void 0, function Focusable2(props) {
+  return _QAUJZR6Ycjs.createElement.call(void 0, TagName, useFocusable(props));
+});
+
+
+
+
+
+exports.FocusableContext = FocusableContext; exports.useFocusable = useFocusable; exports.Focusable = Focusable;

package/cjs/__chunks/NIOJG7C4.cjs

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